python中globa元组列表 python的列表和元组

Python 列表和元组

• 类似C语言的数组：

• 列表

• 列表的类型(list)：
• 列表的添加
• 列表的删除
• 列表的分片(拷贝) ':'
• 列表的拼接
• 列表的比较
• 列表的多次增加（同一个数据）
• 列表的查找
• 列表的翻转：reverse()
• 列表的从小到大自动排列 sort()
• 列表的从大到小自动排列 reverse()

• 列表和元组的区别：
• 元组

• 元组的类型 (tuple)
• 创建单个元组
• 元组的多次增加（同一个数据）
• 元组的增加
• 元组的删除
• 序列：
• list() 变列表
• tuple() 变元组
• str() 变字符串
• len() 计算长度
• max() 返回最大值
• min() 返回最小值
• sum() 返回总和
• sorted() 从小到大
• reversed() 翻转数据
• enumerate() 加序号
• zip() 双方结合
• count() 计算字符/字符串 在字符串中出现多少次

• 模块学习：random模块

类似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)

输出结果: False


list1 = [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))

输出结果: 0

list1 = [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('游戏结果啦')