类似C语言的数组：

列表

列表的类型(list)：

普通列表：

string = ['小明','小王','小李','玛卡巴卡']
print(string)
输出结果：['小明', '小王', '小李', '玛卡巴卡']

混合列表:

string = ['小明','hello',666,'玛卡巴卡']
print(string)
输出结果:['小明', 'hello', 666, '玛卡巴卡']

空列表:

string = []
print(string)
输出结果:[]

列表的添加

添加单个列表：append()
都是只能在末尾加入

string = ['小明','hello',666,'玛卡巴卡']
#添加一个 吧唧吧唧
string.append('吧唧吧唧')输出结果:['小明', 'hello', 666, '玛卡巴卡', '吧唧吧唧']

添加多个列表：extend()
都是只能在末尾加入

string = ['小明','hello',666,'玛卡巴卡']
#添加三个 吧唧吧唧 和 阿巴阿巴 咔叽咔叽
string.extend(['吧唧吧唧','阿巴阿巴','咔叽咔叽'])
print(string)
#注意： 记得 加个[]  每个用逗号 隔开
输出结果：['小明', 'hello', 666, '玛卡巴卡', '吧唧吧唧', '阿巴阿巴', '咔叽咔叽']

插入一个列表 位置自定 insert()
可以随意位置插入新的

头插法

string = ['小明','hello',666,'玛卡巴卡']
#我想插入 嘎嘎嘎 到 第一那里
string.insert(0,'嘎嘎嘎') #是从0开始的哈
print(string)输出结果:['嘎嘎嘎', '小明', 'hello', 666, '玛卡巴卡']

中间插法

string = ['小明','hello',666,'玛卡巴卡']
#我想插入 嘎嘎嘎 到 666 的后面  那么我们看666是第3 个
string.insert(3,'嘎嘎嘎') #下标是从0开始算的哈
print(string)输出结果:['小明', 'hello', 666, '嘎嘎嘎', '玛卡巴卡']

尾插法

string = ['小明','hello',666,'玛卡巴卡']
#我想插入 嘎嘎嘎 到 列表的最后  首先我们发现我们列表有4个数据， 那就是应该是插入4 记住下标是从0开始的
string.insert(4,'嘎嘎嘎') #下标是从0开始算的哈
print(string)输出结果:
['小明', 'hello', 666, '玛卡巴卡', '嘎嘎嘎']

在已有的数据 我想互调位置
需要建立一个 ‘空房间’ 来暂时存放一小会。

string = ['小明','hello',666,'玛卡巴卡']
#我想让 玛卡巴卡 和小明 互换一下位置
#首先 你得知道 小明 是在 string[0] 那里  玛卡巴卡 是在string[3]那里
#不妨打印一下
print(string[0]) #小明
print(string[3]) #玛卡巴卡#互换  先把 小明扔进一个 ‘空房间’  然后把 玛卡巴卡 放到 第一个string[0]里面  然后 把 在空房间的 小明 给到 string[3]
empty_room = string[0] #把小明扔进空房间
string[0] = string[3] #把玛卡巴卡 放到 第一个 string[0]
string[3] = empty_room #再把房间的小明放在 第四个位置 string[3]print(string)输出结果:
小明
玛卡巴卡
['玛卡巴卡', 'hello', 666, '小明']

列表的删除

通过名字来删除 remove()

string = ['小明','hello',666,'玛卡巴卡']
#我想删除 666
string.remove(666)
print(string)输出结果:['小明', 'hello', '玛卡巴卡']
#不知道名字 你输入的名字 列表中没有则报错的

**通过下标来删除 或 整个列表删除 del **

string = ['小明','hello',666,'玛卡巴卡']
#我想删除 666
del string[2]
print(string)输出结果:['小明', 'hello', '玛卡巴卡']#整个列表删除：
del string

在列表移最后一个数据出来 并且我可以用它去做别的 pop()

string = ['小明','hello',666,'玛卡巴卡']
#我想移玛卡巴卡出来  并且给 name 叫 玛卡巴卡
name = string.pop() #把string最后一个数据 玛卡巴卡 移出来 给 name 当名字
print(string) #打印列表  玛卡巴卡 没了
print('name:',name) # 打印name 是不是 叫玛卡巴卡 输出结果:
['小明', 'hello', 666]
name: 玛卡巴卡

列表的分片(拷贝) ‘:’

我想吧列表拷贝一份给别人（全部拷贝）

string = ['小明','hello',666,'玛卡巴卡']
#我想拷贝一份 给我的 Boss
Boss = string[:]#把列表string所有内容给我的Boss
#Boss = string[0:4]    #把列表string所有内容给我的Boss  这个是一样的效果print(Boss) #打印Boss 的列表
print(string) #原有的列表也还在的输出结果:
['小明', 'hello', 666, '玛卡巴卡']
['小明', 'hello', 666, '玛卡巴卡']

我想吧列表拷贝一份给别人（部分拷贝）

string = ['小明','hello',666,'玛卡巴卡']
#我想拷贝一份 给我的 Boss
Boss = string[2:3]#把列表string 666 内容给我的Boss
print(Boss) #打印Boss 的列表
print(string) #原有的列表也还在的输出结果:
[666]
['小明', 'hello', 666, '玛卡巴卡']

其实不拷贝也行，但是他们的数据是同步的 比如string 内容 给了 Boss 如果string 内容变了，那么Boss的内容也是跟着变的 就直接理解成其实是同一个文件，只不过string和Boss都能看。
只是Boss 也指向了 string 这个内容

string = ['小明','hello',666,'玛卡巴卡']
#我想直接给一份 给我的 Boss 注意 这里是没有拷贝哦
Boss = string #把列表string所有内容给我的Boss
print(Boss) #打印Boss 的列表
print(string) #原有的列表也还在的print('------------修改了string之后-----------')#如果我修改了string的内容 比如删除了玛卡巴卡
string.remove('玛卡巴卡')
print(string)
print(Boss)输出结果:
['小明', 'hello', 666, '玛卡巴卡']
['小明', 'hello', 666, '玛卡巴卡']
------------修改了string之后-----------
['小明', 'hello', 666]
['小明', 'hello', 666]
#我们只修改了string 但是Boss 也跟着了

列表的拼接

必须都是列表

list1 = ['hello']
list2 = ['world']
list_new = list1 + list2   #两个列表进行拼接 注意得都是列表
print(list_new)输出结果:['hello', 'world']

列表的比较

**比较的符号: > < >= <= **

list1 = [123,456]
list2 = [124,456]
如何比较的  第一次看大家都是1 再 第二位字符 都是2 再看 第三位字符 3 > 4 吗？ 很显然不是 所以 是 False
value = list1 > list2  #比较
print(value)输出结果: Falselist1 = [123,456]
list2 = [124,456]
list3 = [888,888]print((list1 >= list2) or (list1 < list3)) # or 是表示 或者的意思输出结果:True

列表的多次增加（同一个数据）

乘 就完事了

list1 = [123,456]
print(list1 * 3) #打印3次 列表变成6个了输出结果: [123, 456, 123, 456, 123, 456]

列表的查找

查找有无有

想找的内容 in 列表 或者 想查的内容 not in 列表*

list1 = [123,456,'小明','玛卡巴卡','Boss']
#我想查找一下有没有这个Boss
print('Boss' in list1)输出结果:True #很明显是有的哈list1 = [123,456,'小明','玛卡巴卡','Boss']
#我想查找一下有没有这个666
print(666 in list1)输出结果:False #列表没有666#列表里面 又有个列表
list1 = [123,456,'小明','玛卡巴卡','Boss',['大大','小小']]
#我想查找一下有没有这个 大大
print('大大' in list1)输出结果: False得必须
print('大大' in list1[5])输出结果:True

查找出现了多少次 count(查找的字符)

返回出现查找字符的拥有的次数。

list1 = [123,123,'小明','玛卡巴卡','Boss',['大大','小小']]
#我想查找一下123 有多少个
print(list1.count(123))输出结果:2

查找在哪里出现 index()
index(查找的字符)
index(查找的字符，从哪里开始找，哪里结束)
返回：返回在第几个下标找到的

list1 = [123,123,'小明','玛卡巴卡',123,['大大','小小']]
#我想查找一下123 在哪里出现了 只能找1个
print(list1.index(123))输出结果: 0list1 = [123,123,'小明','玛卡巴卡',123,['大大','小小']]
#我想查找一下123 从第下标为2开始找 到下标为5 看看123在列表的第几个
print(list1.index(123,2,5))输出结果: 4

列表的翻转：reverse()

**把第一个和最后一个互换 第二个和 倒数第二互换 第三个和倒数第三…

list1 = [123,123,'小明','玛卡巴卡',123,['大大','小小']]
#我想查找一下123 在哪里出现了 只能找1个
list1.reverse() #这个你不能定义个变量去 接收数据 比如: x = list1.reverse()
print(list1)    #打印不能print(list1.reverse()) 这样 得分步走输出结果：[['大大', '小小'], 123, '玛卡巴卡', '小明', 123, 123]

列表的从小到大自动排列 sort()

list1 = [9,5,6,2,7,8,1,3,4,10]
#从小到大排列
list1.sort()
print(list1)输出结果:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

列表的从大到小自动排列 reverse()

我们可以通过上面的 reverse() 翻转一下就是从大到小了

list1 = [9,5,6,2,7,8,1,3,4,10]
#从小到大排列
list1.sort() #变成 从小到大
list1.reverse() #翻转一下 变成从大到小
print(list1)
输出结果：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]嫌弃麻烦就这样吧list1 = [9,5,6,2,7,8,1,3,4,10]
#从大到小排列
list1.sort(reverse=True)
print(list1)

列表和元组的区别：

1.类型不一样 列表是 list 元组是 tuple
2.列表 可改内容 元组不可直接更改（但是也是有办法的-切片的方法（拷贝））
3.列表是用[]表示 元组是用() 以及 ‘,’

元组

元组的类型 (tuple)

普通元组

tuple1= ('小明','小王','小李','玛卡巴卡')
print(tuple1)输出结果：('小明', '小王', '小李', '玛卡巴卡')

混合元组:

tuple1 = ('小明','hello',666,'玛卡巴卡')
print(tuple1)输出结果:('小明', 'hello', 666, '玛卡巴卡')

空列表:

tuple1 = ()
print(tuple1)
print(type(tuple1)) #通过type() 查看类型输出结果:()
<class 'tuple'>

创建单个元组

注意：如果想创建一个 单元素 tuple1 = (1) 不是元组类型 是整形

tuple1 = (1)
print(tuple1)
print(type(tuple1))输出结果:1
<class 'int'>

正确的是: 加个逗号

tuple1 = (1,)
print(tuple1)
print(type(tuple1))输出结果：(1,)
<class 'tuple'>也可以这样:
tuple1 = 1,
print(tuple1)
print(type(tuple1))输出结果:(1,)
<class 'tuple'>

元组的多次增加（同一个数据）

跟列表一样的 乘就完事了

tuple1 = 3 * (1,)
print(tuple1)输出结果: (1, 1, 1) #元组变成3 个 了

没有括号 乘 是有区别的

tuple1 = 3 * 1,
print(tuple1)输出结果: (3,) #变成了直接 元组那个数据乘3 的得数了

元组的增加

头插法

tuple1 = ('小明','hello','玛卡巴卡',888)
#我想增加一个 吧唧吧唧 在 元组的第一个
#首先 把 原有的 拷贝给 吧唧吧唧  再 + tuple1    吧唧吧唧 记得 写成元组的形式 括号+逗号
tuple1 = ('吧唧吧唧',) + tuple1[0:4]
print(tuple1)输出结果:('吧唧吧唧', '小明', 'hello', '玛卡巴卡', 888)

中间插法

tuple1 = ('小明','hello','玛卡巴卡',888)
#我想增加一个 吧唧吧唧 在 元组的中间插入、也就是 hello 的后面（第三个）
#首先 把 前两个先 拷贝给 tuple1 再 + 吧唧吧唧  再 + 元组后两个
# 记得 写成元组的形式 括号+逗号
tuple1 = tuple1[0:2] + ('吧唧吧唧',) + tuple1[2:4]
print(tuple1)输出结果:('小明', 'hello', '吧唧吧唧', '玛卡巴卡', 888)

尾插法

tuple1 = ('小明','hello','玛卡巴卡',888)
#我想增加一个 吧唧吧唧 在 元组的最后
#首先 把 原有的 拷贝给 tuple1 + 吧唧吧唧  吧唧吧唧 记得 写成元组的形式 括号+逗号
tuple1 = tuple1[0:4] + ('吧唧吧唧',)
print(tuple1)输出结果：('小明', 'hello', '玛卡巴卡', 888, '吧唧吧唧')

我们通过拷贝的方式 又叫tuple1 指向 拷贝完的内容 原来的其实是会自动消失的，因为没有变量指向它了。

元组的删除

del 数组名字。。。。正常很少这么干。一般都报错 目前没学到有什么好的办法

序列：

list() 变列表

string1 = "hello world" #字符串
string2 = (1,2,3,4,5,9999,123) #元组
print(list(string1))
print(list(string2))输出结果：['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
[1, 2, 3, 4, 5, 9999, 123]

tuple() 变元组

('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
(1, 2, 3, 4, 5, 9999, 123)输出结果:('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')
(1, 2, 3, 4, 5, 9999, 123)

str() 变字符串

string1 = [1,'玛卡巴卡',2,'hhhhh',555] #；列表
string2 = (1,2,3,4,5,9999,123)#元组string1 = str(string1)
string2 = str(string2)
print(string1)
print(string2)
print(type(string1))
print(type(string2))输出结果:
[1, '玛卡巴卡', 2, 'hhhhh', 555]
(1, 2, 3, 4, 5, 9999, 123)
<class 'str'>
<class 'str'>

len() 计算长度

string = 'hello world'
print(len(string))输出结果: 11

max() 返回最大值

返回序列或者参数中的最大值(数据类型得统一)

string = '123456789'
print(max(string))输出结果:9

min() 返回最小值

(数据类型得统一)

string = '123456789'
print(min(string))输出结果:1

sum() 返回总和

可返回值再加自定义值
类型不同 会报错

string = (1,2,3)
print(sum(string))
print(sum(string,10))输出结果:6
16

sorted() 从小到大

string = (1,2,3)
print(sorted(string))输出结果:[1, 2, 3]

reversed() 翻转数据

得加上list

string = (1,2,3)
print(list(reversed(string)))输出结果:[3, 2, 1]

enumerate() 加序号

得加上list

string = (7,8,9)
print(list(enumerate(string)))输出结果:[(0, 7), (1, 8), (2, 9)]

zip() 双方结合

如果没办法结和 直接丢弃

string1 = ['a','b','c'] #列表 元组都行
string2 = ('A','B','C')
print(list(zip(string1,string2)))输出结果:[('a', 'A'), ('b', 'B'), ('c', 'C')]

count() 计算字符/字符串 在字符串中出现多少次

原型: count(sub[,start[,end]])
作用: 返回sub在字符中出现的次数 start 和 end 参数 可选 可不写。

string = 'HELLO WORLD'
number = string.count('L') #查找L 字符在 字符串出现了多少次 也可以查找字符串 'HE'啥的
print(number)输出结果:3

模块学习：random模块

产生随机数：randint() 会返回随机的一个整数
可以设定多少到多少之间的值：
random.randint(1,10)
这就是表示产生1——10的随机数了。
那么我们可以就是 用刚的小练习 来产生一个随机 数

注意：得导入模块（import） 相当于C语言的 头文件吧
调用就是 random.randint(1,10)

import random #导入模块 用import
print('猜数字游戏，猜对了有奖')number = random.randint(1,10) #设定随机数为1——10的数字
string = input('你输入0-10的数字，看看你有没有猜对: ')
value  = int(string)if value == number:print('恭喜你猜对了')
else:if value > number:print('大了，大了')else:print('小了，小了') while value != number:string = input('猜错啦 再来一次吧 ')value  = int(string)if value == number:print('恭喜你猜对了')else:if value > number:print('大了，大了')else:print('小了，小了')  print('游戏结果啦')

Python入门(三) 列表和元组相关推荐

1. 第三章 Python容器：列表、元组、字典与集合

   3.1 列表和元组 除字符串以外,Python还有另外两种序列结构:元组和列表.他们都可以包换0个或多个元素,元组并不要求所含元素的种类相同,每个元素可以是各种类型的Python对象. 元组是不可变的 ...

2. python集合和列表、安从小到大的顺序组合成一个字典_第3章 Python容器：列表、元组、字典与集合...

   3.1 列表和元组 除字符串外,Python 还有另外两种序列结构:元组和列表.它们都可以包含零个或多个元 素.与字符串不同的是,元组和列表并不要求所含元素的种类相同,每个元素都可以是任 何 Pyth ...

3. Python.习题五 列表与元组（下）

   Python.<习题五> 列表与元组 11.假设列表lst_info=[["李玉","男",25],["金忠","男& ...

4. python字符串，列表，元组，字典的基本操作

   python字符串,列表,元组,字典的基本操作 文章目录 python字符串,列表,元组,字典的基本操作 一.字符串 1.1字符串的输出 1.2字符串的输入 1.3下标和切片 1.4 字符串常见操作 ...

5. 基于jupyter编程环境下——Python入门：列表4

   列表 四.操作列表 1.使用列表的一部分 -- 切片 2.元组 Python资料:Python编程XG:从入门到实践. 四.操作列表 1.使用列表的一部分 -- 切片 在前面学习了如何访问单个列表元素 ...

6. 附加 集合数据_最全的实例详解：Python字符串、列表、元组、字典、集合的补充...

   本文内容主要介绍了Python字符串.列表.元组.字典.集合,结合实例形式详细分析了Python字符串.列表.元组.字典.集合常见函数使用方法及相关操作注意事项,需要的朋友可以参考下!!! 附加: p ...

7. python中的列表和元组_python中列表和元组的区别

   如果有了解过python中的列表和元组,你可能会知道相对于列表,元组是不可变的,也就是说元组中的数据不能随意更改.除了列表是用中括号表示而元组是用小括号表示之外,这两种数据类型好像并没有什么不同,都是 ...

8. python元组读取到列表_Python 学习笔记（1）Python容器：列表、元组、字典与集合...

   Python容器:列表.元组.字典与集合 列表: 1.列表 的创建 使用[ ] 或者list()创建列表:empty_list = [ ] 或者 empty_list= list() 使用list() ...

9. python假设有三个列表_python基础三(列表和元组)

   1.序列概述: ?python内置了许多种序列,列表.元组.字符串等. ?列表和元组的不同在于,列表是可以修改的,而元组不可以,这意味着列表用于需要中途添加元素的情形,而元组适用于禁止修改元素的情形. ...

最新文章

1. Win10隐藏硬盘分区
2. 数据恢复西藏之旅--硬盘也有高原反应
3. Eschool校园网平台介绍
4. makefile格式-实践一
5. PyWebIO，让 Pandas 原地起飞的神器！
6. HTTP/2 流量调试
7. C++中WSAAsyncSelect模型的用法例程
8. Asp.Net Core 中IdentityServer4 授权中心之应用实战
9. java arraylist范围_Java常见集合之ArrayList深入分析
10. 08.Numpy数组迭代
11. 排序：快速排序与归并排序
12. 力扣-205 同构字符串
13. 关于AOP（面向方面的编程）
14. java动态数组_Java实现动态数组
15. 别再说互联网寒冬了，为何不从自己身上找找原因呢
16. 2022年计算机二级WPS Office高级应用与设计复习题及答案
17. excel的if函数嵌套使用
18. vue项目中加载使用腾讯地图
19. go 怎么等待所有的协程完成_优雅地等待子协程执行完毕
20. 【链表】两个无序链表合并成递增有序链表（利用原表空间）

热门文章

1. 以太坊黄皮书（1~6章）
2. 泊松分布的矩母函数与特征函数
3. c语言随机生成5到10,C语言生成随机数
4. 一闪一闪亮晶晶，我有一颗小星星
5. 微信按住说话HTML实现
6. 同一局域网下两台电脑传文件
7. 初一年级上学期计算机课知识总结,精选七年级上册信息技术教案范文3篇
8. 编程语言排行榜：你选对了吗？
9. Conda：miniconda
10. 人工智能Java SDK：语音识别（ASR）【长语音】