- Python入门——数据类型
- 1、数据类型
- 1、分类 ：
- 2、查看数据类型方法 ：type ( )
- 3、数据类型转换 ： int list tuple set
- 4、可变和不可变数据类型
- 2、数值数据
- 1、分类 ：整数（ int ）、浮点数（ float ）、复数（ complex ） 注意：Python中的整数不限大小，即自带高精度
- 2、整数的不同表现形式，即不同的进制
- 3、数值类型转换函数
- 4、数值函数（调用时需导入 math 包，即 import math）
- 5、三角函数（调用时需导入 math 包，即 import math）
- 6、随机数函数（需要导入 random 包，即 import random）
- 3、字符串
- 1、基本概念
- 2、字符串的切片
- 3、转义字符
- 4、字符串中的特殊运算符
- 5、字符串的格式化运算符
- 6、字符串的内置方法
- 4、列表
- 1、列表的定义方法
- 2、列表的访问
- 3、列表函数
- 4、列表方法
- 5、列表生成式（推导式） ：用于简单地创建列表
- 5、元组
- 1、元组的数据类型是不可变数据类型，不能增加，删除，改变，只能查找。
- 2、元组的定义
- 3、元组函数（ 用 tup 表示元组，以显示其位置）
- 6、字典
- 1、定义方式
- 2、字典的内置方法
- 3、字典的遍历方式
- 4、补充概念
- 5、补充
- 6、字典推导式
- 7、集合
- 1、定义方法
- 2、特点
- 3、集合的内置方法
- 4、集合的运算
- 5、补充
- 8、深拷贝和浅拷贝
- 1、浅拷贝 ：只拷贝对象的第一层 ，第二层数据是指向的，为共享数据。
- 2、深拷贝 ：全部拷贝对象，两个对象的数据完全不共享。（只有一种深拷贝）：
- 9、数据类型的通用方法
- 1、算数运算符
- 2、遍历
1、数据类型 1、分类 ：
数值数据、字符串、列表、元组、字典、集合
2、查看数据类型方法 ：type ( )a = 2
print(type(a)) # （1）不可变数据类型：字符串、数字、元组 （若修改值，内存地址会改变）
（2）可变数据类型：列表、字典、集合 （若修改值，内存地址不会改变）
2、数值数据 1、分类 ：整数（ int ）、浮点数（ float ）、复数（ complex ） 注意：Python中的整数不限大小，即自带高精度 2、整数的不同表现形式，即不同的进制（1）以 0b 开头的数字是二进制。 如：0b101101101 （十进制是365）
（2）以 0o 开头的数字是八进制。 如：0o555 （十进制是365）
（3）以 0x 开头的数字是十六进制。 如：0x16d （十进制是365）
（4）补充：不同进制的转换方法（以十进制的23为例）
(i) 转换为二进制：0001 0111 （将十进制的数不断除以2，将每次所得的余数倒着排列得到二进制
(ii) 转换为八进制：27（将二进制3个3个地排列，然后按照八进制的算法计算，即 000 010 111（010是2 , 111是7，八进制是27））
(iii) 转换为十六进制：17（将二进制4个4个地排列，然后按照十六进制的算法计算，即0001 0111（0001是1， 0111是7）
3、数值类型转换函数（1）int ( ) 转换为整数(小数全部舍去) ；（2）float ( ) 转换为浮点数
4、数值函数（调用时需导入 math 包，即 import math）（1）abs ( ) 、sqrt（ ）、floor（）、ceil（）、用法与C一样
（2）exp（）：返回 e 的 x 次幂
（3）log（）：返回 x 的自然对数
（4）log10（）：返回以基数为10的对数
（5）max（）/ min（）：返回参数中的最大/最小值
（6）modf（）：将该数分为整数和浮点数分别存入元组，符号一致，整数部分作为浮点数返回
（7）pow（ x , y ）：返回 x 的 y 次方
（8）bin（） / oct（）/ hex（） ：将十进制转化为二进制 / 八进制 / 十六进制
5、三角函数（调用时需导入 math 包，即 import math）（1）sin（）、cos（）、tan（）、asin（）、acos（）、atan（）
（2）degrees（）：将角度 x 从弧度转换为度
（3）radians（）：将角度 x 从度转换为弧度
6、随机数函数（需要导入 random 包，即 import random）（1）randrange ( [start，] stop [ ，step] ) ：返回从范围（start，stop，step）中随机选择的元素
（2）uniform（x，y）：返回随机浮点数 r（ x <= r < y ）
（3）random（）：返回随机浮点数 r（ 0 <= r < 1 ）
3、字符串 1、基本概念（1）需要用一对单引号（’ ‘）或一对双引号（" "）或一对三个单引号（’‘’ ‘’‘）或一对三个双引号（“”" ‘’’‘’'）
（2）注意（1）中的引号用法没有太大区别，但有以下区别
str = " I'm a teacher." # 字符串中有'时外面需要用"
str = ' He said "She is a teacher."' # 字符串中有"时外面需要用'
（3）Python中没有字符类型，单个字符默认为长度为1的字符串
（4）字符串是不可变数据类型
2、字符串的切片（1）格式要求：string [star : end : step] （注：star 是开始切片的位置，end 是指结束切片的位置，step 是指切片的步长/间隔）
（2）注意点：（i）字符串是不可变数据类型，所以切片不改变原有的字符串，而是复制指定内容，生成新字符串
str = "I love you."
m=str[1:4]
print(m) # I l
print(str) # I love you.
（ii）字符串切片内容包含第一个指定位置，不包含最后一个指定位置
（3）特殊情况
（i）若 step 等于负数，意味着从右数到左
（ii）若 start 和 end 等于负数，则从右数到左（注意：最右端的的序号是 -1）
str = "I love you."
m = str[-2:-5:-1]
print(m) # uoy
print(str) # I love you.
（1）\a、\b(退格)、\n、\t、\v(垂直制表)、\s(空格)、\\ (普通反斜线)
（2）在紧靠字符串引号前面加上 r/R ，在 Python 中表示原生字符串，无论内部是否有转义字符，直接全部照样输出
4、字符串中的特殊运算符（1）+ 和 * 分别表示字符串连接和重复字符串
（2）[ ] 表示字符索引得到单个字符
（3）[ : ] 表示字符串切片
（4）in 和 not in 表示成员运算符，根据字面意思理解即可
a='hello'
print('ll'in a) #True
（5）r/R ：结合3.3.3.(2) 理解
（6）补充：（i）ord ( ‘字符’ ) 获取字符所对应的编码；（ii）chr ( ‘数字’ ) 获取数字所对应的字符
print (ord('a')) # 97
print (chr(65)) # A
（1）用 % 作为占位符输出
print('I am %s ,I am %d ' %('Lihua',18)) # I am Lihua ,I am 18
（i）%s 表示字符串；（ii）%i 表示带符号的十进制整数；（iii）%u 表示不带符号的十进制整数；（iv）%o 表示八进制整数
（v）%d ：带符号的十进制整数（%nd ：整数占n位，不够时用空格补在前面；%0nd ：整数占n位，不够时用0补在前面；）
（vi）%f ：表示浮点数；（vii）%x /%X ：表示十六进制整数；（viii）%.ng：输出n位有效数字
（2）用 format 方法：用 { } 占位，然后使用尾缀 . format ( 内容 )
（i）一一对应
print('我是{},今年{}岁'.format ('张三',18)) # 我是张三,今年18岁
（ii）根据 { } 中所给的数字顺序填入（从0开始）
print('我是{1},今年{0}岁'.format (18,'张三')) # 我是张三,今年18岁
（iii）变量赋值
print('我是{name},今年{age}岁'.format (age = 18，name = '张三')) # 我是张三,今年18岁
（iv）将（ii）和（iii）混合使用，但是需要注意：变量赋值需要在最后写
print('我是{0},今年{}岁'.format ('张三',age = 18)) # 我是张三,今年18岁
（v）拆包
a = [ '张三',18 ]
print('我是{},今年{}岁'.format (*a)) # 我是张三,今年18岁
（vi）字典
a = {'nane':'张三','age':18}
print('我是{},今年{}岁'.format(**a)) # 我是张三,今年18岁
注：在下文中统一用 str 表示表示具体的字符串，以显示代码中字符串所在位置
（1）len（ str ）：字符串长度
（2）判断类
（i）str.startswith（ ’ 字符 ’ ）：判断字符串是否以括号内的字符开头 （严格区分大小写）
print('hello'.startswith('h')) # True
（ii）str.endswith（ ’ 字符 ’ ）：判断字符串是否+以括号内的字符结尾 （严格区分大小写）
（iii）str.isalpha：判断是否全是字母（空格也不行）
print('lovelove'.isalpha) # True
（iv）str.isdigit ：判断是否全是数字
（v）str.isalnum：判断是否全是数字和字母
（vi）str.space：判断是否全是空格
（3）查找类
（i）str.find（ ’ 字符 ’ ）/ str.index（ ’ 字符 ’ ） ： 获取括号内字符的下标，返回最小的下标
（ii）str.rfind（ ’ 字符 ’ ）/ str.rindex（ ’ 字符 ’ ） ： 获取括号内字符的下标，返回最大的下标
注意：find 和 index 的区别是如果字符串中没有要查找的字符，find 返回 -1 ，而 index 会报错
还可以指定查找的范围：str.find（ ’ 字符 ’ ，start，end）
print('love you.'.find('o')) # 1
print('love you.'.rfind('o')) # 6
（4）计算次数类
str.count（ ’ 字符 ’ ）：统计括号内字符出现的次数
（5）替换内容类
str.replace（ ’ 替换前的字符 ’ ， ’ 替换后的字符 ’ ）
（6）切割字符串类
（i）str.split（ ’ 切割的分隔符 ’ ，切割的次数n ） ：以括号中的切割分隔符切割n次 （注：从左往右分割）
print('lovelove'.split('v',1)) # ['lo', 'elove']
（ii）str.rsplit（ ’ 切割的分隔符 ’ ，切割的次数n ） ：以括号中的切割分隔符切割n次 （注：从右往左分割）
print('lovelove'.rsplit('v',1)) # ['lovelo', 'e']
（iii）str.splitlines（ ）：以 \n 作为标识符切割
（iv）str.partition（ ’ 分隔符 ’ ）：以指定的分隔符将字符串分割为（前面 + 分隔符 + 后面 ）三部分 （从左往右找分隔符）
（v）str.rpartition（ ’ 分隔符 ’ ）：以指定的分隔符将字符串分割为（前面 + 分隔符 + 后面 ）三部分 （从右往左找分隔符）
注：可以利用（iv）或（v）获取文件的命名和格式
print('我的文件.docx'.partition('.')) # ('我的文件', '.', 'docx')
（7）修改大小写类
（i）str.capitalize（ ）：使第一个单词的首字母大写，其余字母均小写
（ii）str.upper（ ）：让所有字母大写
（iii）str.lower（ ）：让所有字母小写
（iv）str.title（ ）：让每个单词的首字母大写，其余均小写
a = 'i lOve YoU.'
print(a.capitalize()) # I love you.
print(a.upper()) # I LOVE YOU.
print(a.lower()) # i love you.
print(a.title()) # I Love You.
（8）空格处理
（i）str.ljust（指定长度n， ’ 填充字符（默认是空格） ’ ） ：左对齐
（ii）str.rljust（指定长度n， ’ 填充字符（默认是空格） ’ ）：右对齐
（iii）str.center（指定长度n， ’ 填充字符（默认是空格） ’ ）：中对齐
注：填充对齐是，如果字符串长度大于指定长度，则按照字符串原有长度输出
a = 'love'
print(a.ljust(10，'*')) # love******
print(a.rljust(10，'*')) # ******love
print(a.apple(10，'*') # ***love***
（iv）str.lstrip（ ）：去掉左边多余的全部空格
（v）str.rstrip（ ）：去掉右边多余的全部空格
（vi）str.strip（ ）：去掉左、右边多余的全部空格
a = ' love love '
print(10,a.ljust('*')) # love******
print(10,a.rljust('*')) # ******love
print(10,a.apple('*')) # ***love***
（9）连接类
’ 连接符 ’ .join（ ’ 连接内容 ’ ）
print('*'.join('hello')) # h*e*l*l*o
print('*'.join(['he','emm'])) # he*emm
print('*'.join(('he','emm'))) # he*emm
（1）str = [‘张三’，‘李四’]
（2）str = [‘张三’，98， ‘李四’ ，47] （列表中的元素数据类型不同）
（3）str = [[‘张三’，98]，[‘李四’，47]] （列表中的元素为列表）
（4）str = ((‘张三’， ‘李四’ )) （元组）
2、列表的访问可以通过下标索引，也可以对元素进行切片
3、列表函数注：列表统一用 list 表示，以显示代码中列表所在位置
（1）len（list）：列表中元素的个数
（2）max（list）：列表中元素的最大值
（3）min（list）：列表中元素的最小值
（4）list（seq）：将元组转换为列表 （这里的 list 不是指具体的列表，而是指数据类型，和 int (3.14) 类似）
4、列表方法注：在下文中统一用 list 表示列表，以显示代码中列表所在位置
（1）添加元素类
（i）list.append（ ’ 添加的元素 ’ ）：在原有的列表后面添加新的对象
（ii）list.insert（位置n， ’ 添加的元素 ’ ）：在指定的位置插入指定的对象
（iii）list.extend（seq）：在原有的列表后面加上多个元素，seq 内容必须是可迭代对象
（2）删除类
（i）list.pop（位置n（默认是最后一个元素））：删除指定位置的数据
（ii）list.remove（ ’ 删除的对象 ’ ）：删除括号内的对象，若没有该元素，会报错
（iii）list.clear（）：全部清空
（iv）del.list [位置n]：删除指定位置的元素 （尽量不要用 del ）
（3）查询类
（i）list.index（ ’ 查询的对象 ’ ）：返回第一个该对象的位置 （若查询的元素不存在与列表中，会报错）
（ii）list.count（ ’ 查询的对象 ’ ）：返回该对象出现的个数
（4）修改类
直接通过下标来修改
（5）排列类
（i）list.sort（ ）：默认是讲列表的数据从小到大排序，若需要倒序，则可以在括号中补上 reverse = True 即可
a = [8, 5, 4, 2, 7, 8, 1, 10, 3]
a.sort()
print(a) # [1, 2, 3, 4, 5, 7, 8, 8, 10]
b = [8, 5, 4, 2, 7, 8, 1, 10, 3]
b.sort(reverse=True)
print(b) # [10, 8, 8, 7, 5, 4, 3, 2, 1]
（ii）sorted（ list ）：会生成新的列表，不改变原有的列表数据和顺序
a = [8, 5, 4, 2, 7, 8, 1, 10, 3]
b = sorted(a)
print(a) # [8, 5, 4, 2, 7, 8, 1, 10, 3]
print(b) # [1, 2, 3, 4, 5, 7, 8, 8, 10]
（iii）liet.reverse（ ）：反转列表中的元素 （其实也对于 list [：：-1] ）
a = [8, 5, 4, 2, 7, 8, 1, 10, 3]
a.reverse()
print(a) # [3, 10, 1, 8, 7, 2, 4, 5, 8]
a = [8, 5, 4, 2, 7, 8, 1, 10, 3]
print(a[::-1]) # [3, 10, 1, 8, 7, 2, 4, 5, 8]
（6）复制类
list.copy（ ）：复制内容不变，但是内存空间不同
a = [1,2,3,4]
b = list.copy(a)
print(a,b) # [1, 2, 3, 4] [1, 2, 3, 4]
print(id(a),id(b)) # 2118281212032 2118281241472
a = [i for i in range(5)]
b = [i*i for i in range(5)]
c = [i for i in range(5) if i % 2 == 0]
print(a,b,c) # [0, 1, 2, 3, 4] [0, 1, 4, 9, 16] [0, 2, 4]
a = [(x,y) for x in range(2,4) for y in range(5,7)]
print(a) # [(2, 5), (2, 6), (3, 5), (3, 6)]
（1）需要（ ）将元素包含
（2）当元组中只有一个元素时，需要在元素后面加一个逗号
a = (9)
b = (9,)
print(type(a),type(b)) # // a的数据类型是整数，b的数据类型是元组
（1）tup.index ( ) ：查找括号内容在元组中的位置
words = (1,2,3,4,5,6,7,8,9,10)
print(words.index(2)) # 1
（2）tup.count ( ) ：统计括号内容在元组中的个数
words = (1,2,3,4,5,6,1,2,3,4,5,6)
print(words.count(1)) # 2
（1）用 { } 将键值对（key-value）包含，键与值之间用分号( : )连接，键值对之间用逗号( , )连接。
（2）value 可以是任意一种数据类型，而 key 只能是不可变数据类型（数字，字符串，元组）。
2、字典的内置方法（1）查找类
（i）dict [ key ]：键必须是字符串；如果该键不存在，系统会报错
a = {'name':'张三','age':18}
print(a['name']) # 张三
print(a['height']) #// 报错
（ii）dict.get ( key ，a )：若该键不存在，则会返回值 a ，默认是None；但是不会把默认值加到字典里。
a = {'name':'zs','age':18}
print(a.get('height')) # None
print(a.get('height',180)) # 180
print(a) # {'name': 'zs', 'age': 18}
（2）修改类
dict [ key ]：如果 key 存在于字典中，则会直接修改数据；如果 key 不存在，则会将该key补充到字典中。
a = {'name':'zs','age':18}
a['height'] = 180
print(a) # {'name': 'zs', 'age': 18, 'height': 180}
（3）删除类
（i）dict.pop ( key )：删除字典中括号内指定 key 对应的值，并返回删除的 value 值。
a = {'name':'张三','age':18}
b = a.pop('age')
print(a,b) # {'name': '张三'} 18
（ii）dict.popitem ( )：随机删除字典中的一个键值对，并返回该键值对。
a = {'name':'张三','age':18}
b = a.popitem()
print(a,b) # {'name': '张三'} ('age', 18)
（iii）del dict [ key ] ：删除指定的 key 对应的键值对，不返回值。
a = {'name':'张三','age':18}
del a['name']
print(a) # {'age': 18}
（iv）dict.clear ( ) ：将字典中的所以元素清空。
（4）增加类
dict.update ( dict1 ) ：将 dict1中的内容增加到 dict 中。
a = {'name':'张三'}
b = {'age':18}
a.update(b)
print(a,b) # {'name': '张三', 'age': 18} {'age': 18}
（1）利用 for 循环直接遍历，但是直接得到的只有 key 。
a = {'name':'张三','age':18}
for x in a :
print(x,end = ' ') # name age
print()
for x in a :
print(x,'=',a[x],end = ' ') # name = 张三 age = 18
（2）获取所有的 key ，然后遍历 key 得到 value。（相比于方法（1）多了一步，更加麻烦，不要使用这种方法）
a = {'name':'张三','age':18}
for x in a.keys() :
print(x,'=',a[x],end = ' ') # name = 张三 age = 18
（3）直接获取所有的 value （这种方法只能得到 value ，不能通过 value 返回得到 key）
a = {'name':'张三','age':18}
for x in a.values():
print(x,end = ' ') # 张三 18
（4）获取键值对：dict.items ( )
（i）通过一个变量获取
a = {'name':'张三','age':18}
for x in a.items() :
print(x[0],'=',x[1],end = ' ') # name = 张三 age = 18
（ii）通过两个变量获取（拆包）
a = {'name':'张三','age':18}
for x,y in a.items() :
print(x,'=',y,end = ' ') # name = 张三 age = 18
（1）字典内的数据保存是无序的，不能通过下标的方式查找。
（2）字典不支持加法运算，但是字符串，列表和元组支持加法运算。
print('he '+'emm') # he emm
print((1,3)+(1,4)) # (1, 3, 1, 4)
print([1,3]+[1,4]) # [1, 3, 1, 4]
（1）统计列表中各个字符出现的次数
chars = ['a','b','c','a','b','d']
count = {}
for char in chars :
if char in count :
count[char] += 1
else :
count[char] = 1
print(count) # {'a': 2, 'b': 2, 'c': 1, 'd': 1}
chars = ['a', 'b', 'c', 'a', 'b', 'd']
count = {}
for char in chars:
if char not in count :
count[char] = chars.count(char)
print(count) # {'a': 2, 'b': 2, 'c': 1, 'd': 1}
（2）判断输入的用户名是否存在，若存在则提醒，若不存在则要求用户输入年龄，加入原有用户列表中，并输出。
names = [{'name': 'he', 'age': 19}, {'name': 'l', 'age': 18}]
x = input("请输入您的姓名：")
for t in names:
if x == t['name']:
print('您输入的名字已存在。')
break
else:
person1 = {'name': x}
age1 = int(input("请输入您的年龄："))
person1['age'] = age1
names.append(person1)
print(names) # [{'name': 'he', 'age': 19}, {'name': 'l', 'age': 18}, {'name': 'li', 'age': 20}]
（3）将字典中的 key 和 value 调换位置（方法2是用字典推导式完成）
a = {'a':1,'b':2,'c':3}
b = {}
for k,v in a.items()
b[v] = k
print(b) # {1: 'a', 2: 'b', 3: 'c'}
a = {'a':1,'b':2,'c':3}
b = {v:k for k,v in a.items()}
print(b) # {1: 'a', 2: 'b', 3: 'c'}
7、集合 1、定义方法dict1 = { v:k for k,v in dict2.items( ) } ：将 dict2 中的 key 和 value 交换
可以使用 { } 或set ( ) 创建，但是创建一个空集合必须用 set( ) 。空集合的表示方法是 set ( )，而不是 { } ，{ } 表示空字典。
2、特点（1）集合内的元素不能有重复的元素。
（2）集合是无序的，不能通过下标查找。
3、集合的内置方法（1）增加类
（i）set.add( ) 或 set.update( ) ：直接将括号内的元素加入到原集合中。
区别：add添加元素是直接将元素当成一个整体添加到集合中；而update如果添加的元素是字符串时，会将字符串拆分。（如果插入的元素是列表等可变数据类型，add会报错，而update会将可变数据类型拆分成不可变数据类型（但是只能拆一层））
a = {'he','xxx'}
a.add('lo')
a.update('ve')
print(a) # {'he', 'e', 'v', 'xxx', 'lo'}
（ii）set.union( ) ：不改变原有的集合，添加元素并创建新集合。如果添加的元素是字符串，会将字符串拆分。
a = {'he','l'}
b = a.union({'love'})
c = a.union('love')
print(a,b,c,sep = ' ') # {'l', 'he'} {'l', 'love', 'he'} {'l', 'he', 'o', 'v', 'l', 'e'}
（2）删除类
（i）set.pop() ：随机删除集合内的一个元素。pop默认删除最左端的元素，但是由于集合的无序性，所以删除对象具有随机性，但是，当集合是由列表和元组转换的集合时，pop删除最左端数据，因为集合对列表和元组具有排序（升序）作用。
a = {'he','emm','love'}
b = set([2,3,5,7,0,8,1,2,3,4])
a.pop()
b.pop()
print(a,b) # {'he', 'emm'} {1, 2, 3, 4, 5, 7, 8}
（ii）set.clear() ：将集合内的元素全部清除。
a = {'he','emm','love'}
a.clear()
print(a) # set()
（iii）set.remove( ) 或 set.discard( ) ：删除集合内括号中指定的元素。如果集合内没有括号中的元素，remove 会报错，discard 不会。
4、集合的运算（1）取集合的交集：可以使用 & 或 intersection 方法实现
a = {'xxx','emm','love'}
b = {'xxx','emm','you','i'}
print(a & b) # {'emm', 'xxx'}
print(a.intersection(b)) # {'emm', 'xxx'}
（2）取集合的并集：可以使用 | 或 union 方法实现
a = {'emm','xxx','love'}
b = {'emm','xxx','you','i'}
print(a | b) # {'you', 'i', 'emm', 'xxx', 'love'}
print(a.union(b)) # {'you', 'i', 'emm', 'xxx', 'love'}
（3）取集合的差集：可以使用 - 或 difference 方法实现
a = {'emm', 'l', 'love'}
b = {'emm', 'l', 'you', 'i'}
print(a - b) # {'love'}
print(b - a) # {'you', 'i'}
print(a.difference(b)) # {'love'}
（4）取集合的对称差集（差集的并集）：可以使用 ^ 或 symmetric_difference 方法实现
a = {'emm', 'xxx', 'love'}
b = {'emm', 'xxx', 'you', 'i'}
print(a ^ b) # {'i', 'love', 'you'}
print(a.symmetric_difference(b)) # {'i', 'love', 'you'}
（5）判断一个集合是否是另一个集合的子集：可以使用 >= 或 issubset( ) 方法实现
a = {'emm', 'xxx', 'love'}
b = {'emm', 'xxx', 'you', 'i', 'love'}
print(a.issubset(b)) # True
print(a <= b) # True
（6）判断一个集合是否是另一个集合的父集：可以使用 <=& 或 issuperset( ) 方法实现
a = {'emm', 'xxx', 'love'}
b = {'emm', 'xxx', 'you', 'i', 'love'}
print(b.issuperset(a)) # True
print(a <= b) # True
（1）将列表去重：将列表转换为集合，再转换为列表
a = ['emm','xxx','i','love','you','xxx','love']
b = list(set(a))
print(b) # ['i', 'love', 'xxx', 'emm', 'you']
（2）内置类：list、tuple、set 之间可以相互转换
a = ['abc','def','love','you']
b = set(a)
c = tuple(a)
d = list(b)
print(b,c,d,sep=' ') # {'def', 'you', 'abc', 'love'} ('abc', 'def', 'love', 'you') ['def', 'you', 'abc', 'love']
（3）内置函数 eval ：可执行字符串内的代码
a = 'print("xxx,i love you")'
eval(a) # xxx,i love you
（4）内置函数JSON（需要调用JSON，即需要 import json ）
（i）json.dumps( ) ：将括号内的列表、元组、字典等转化为 JSON 字符串
（ii）json.loads( ) ：将字符串转化为列表、元组、字典等。 也可以使用 eval
import json
a = ['i','tea','you','xxx']
b = json.dumps(a)
print(b,type(b)) # ["i", "tea", "you", "xxx"] | Python | JSON |
|---|---|
| 字符串 | 字符串 |
| 字典 | 对象 |
| 列表、元组 | 数组 |
| True | true |
| False | false |
words = ['zhang','liu',['he','li','wang'],'guo']
words1 = words.copy()
print(words1) # ['zhang', 'liu', ['he', 'li', 'wang'], 'guo']
words[0] = 1 #//改变第一层数据，拷贝后的数据不改变
words[2][1] = 2 #//改变第二层数据，拷贝后的数据也改变
print(words1) # ['zhang', 'liu', ['he', 2, 'wang'], 'guo']
import copy
words = ['zhang','liu',['he','li','wang'],'guo']
words1 =copy.deepcopy(words)
print(words1) # ['zhang', 'liu', ['he', 'li', 'wang'], 'guo']
words[0] = 1 #//深拷贝后的数据与原对象数据不共享，所以改变原对象的数据，深拷贝的数据不改变
words[2][1] = 2 #//深拷贝后的数据与原对象数据不共享，所以改变原对象的数据，深拷贝的数据不改变
print(words1) # ['zhang', 'liu', ['he','li', 'wang'], 'guo']
| 运算符 | 表达式 | 结果 | 描述 | 支持的数据类型 |
|---|---|---|---|---|
| + | [1,2] + [3,4] | [1,2,3,4] | 合并 | 字符串、列表、元组 |
| - | {1,2,3,4} - {1,2} | {3,4} | 集合求差集 | 集合 |
| * | [‘love’] * 2 | [‘love’,'love] | 复制 | 字符串、列表、元组 |
| in | 3 in {1,2,3} | True | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 4 not in {1,2,3} | True | 元素是否不存在 | 字符串、列表、元组、字典 |
注意：in 和 not in 用于判断字典时，是判断 key 是否存在，而不是 value
2、遍历通过 for…in 可以实现对字符串、列表、元组、字典、集合等可迭代对象进行遍历。
（1）字符串的遍历
a = 'i love you'
for x in a :
print(x,end='-') # i- -l-o-v-e- -y-o-u-
（2）列表的遍历
a = ['he','i','love']
for x in a :
print(x,end='-') # he-i-love-
（3）元组的遍历
a = ('he','i','love')
for x in a :
print(x,end='-') # he-i-love-
（4）带下标的遍历
a = [520,13,14]
for i,x in enumerate(a) :
print(i,x,sep =' ',end = ' / ') # 0 520 / 1 13 / 2 14 /
a = {'a':520, 'n':13,'liu': 14}
for i,x in enumerate(a) :
print(i,x,sep =' ',end = ' / ') # 0 a / 1 n / 2 liu /
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）