Python入门——数据类型

Python入门——数据类型

---

1、数据类型

1、分类 ：

数值数据、字符串、列表、元组、字典、集合

2、查看数据类型方法 ：type ( )

a = 2
print(type(a))   # <class 'int'>

3、数据类型转换 ： int list tuple set

4、可变和不可变数据类型

（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.

3、转义字符

（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

5、字符串的格式化运算符

（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岁

6、字符串的内置方法

注：在下文中统一用 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

4、列表

1、列表的定义方法

（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

5、列表生成式（推导式） ：用于简单地创建列表

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)]

5、元组

1、元组的数据类型是不可变数据类型，不能增加，删除，改变，只能查找。

2、元组的定义

（1）需要（ ）将元素包含

（2）当元组中只有一个元素时，需要在元素后面加一个逗号

a = (9)
b = (9,)
print(type(a),type(b))           # <class 'int'> <class 'tuple'>   // a的数据类型是整数，b的数据类型是元组

3、元组函数（ 用 tup 表示元组，以显示其位置）

（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

6、字典

1、定义方式

（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}

3、字典的遍历方式

（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

4、补充概念

（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]

5、补充

（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'}

6、字典推导式

dict1 = { v:k for k,v in dict2.items( ) } ：将 dict2 中的 key 和 value 交换

7、集合

1、定义方法

可以使用 { } 或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

5、补充

（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"] <class 'str'>
c = json.loads(b)
print(c,type(c))     # ['i', 'tea', 'you', 'xxx'] <class 'list'>
d = eval(b)
print(d,type(d))     # ['i', 'tea', 'you', 'xxx'] <class 'list'>

Python	JSON
字符串	字符串
字典	对象
列表、元组	数组
True	true
False	false

8、深拷贝和浅拷贝

1、浅拷贝 ：只拷贝对象的第一层 ，第二层数据是指向的，为共享数据。

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']

2、深拷贝 ：全部拷贝对象，两个对象的数据完全不共享。（只有一种深拷贝）：

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']

9、数据类型的通用方法

1、算数运算符

运算符	表达式	结果	描述	支持的数据类型
+	[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 /