[Python知识库]Python学习_基础_07_基本数据类型及其常用内置方法

Python-基本数据类型的常用内置方法

一、数字类型

1. int类型

   定义：

   age = 20  # 本质为 age = int(20)
   
   # 注意：名字+括号的意思就是调用某个功能，比如
   # print(...)调用打印功能
   # int(...)调用创建整型数据的功能
   # float(...)调用创建浮点型数据的功能
   

   类型转换：

   ? （1）纯数字的字符串转成int

   # 纯数字的字符串转成int
   res = int('100111')
   print(res, type(res))  # 100111 <class 'int'>
   

   ? （2）十进制转成其他进制

   # 十进制 -> 二进制
   11 - > 1011
   1011-> 8 + 2 + 1
   print(bin(11))  # 0b1011  0b表示二进制
   
   # 十进制 -> 八进制
   print(oct(11))  # 0o13  0o表示八进制
   
   # 十进制 -> 十六进制
   print(hex(11))  # 0xb  0x表示十六进制
   print(hex(123))  # 0x7b
   

   ? （3）其他进制转十进制

   # 二进制 -> 十进制
   print(int('0b1011',2))  # 11
   
   # 二进制 -> 八进制
   print(int('0o13',8))  # 11
   
   # 二进制 -> 十六进制
   print(int('0xb',16))  # 11
   

2. float类型

   定义：

   salary = 333.3  # 本质salary = float(333.3)
   

   类型转换：

   res = float("3.1")
   print(res, type(res))  # 3.1 <class 'float'>
   

int与float没有需要掌握的内置方法，它们的使用就是数学运算和比较运算。

二、字符串类型（重要）

定义：

msg = 'hello python'  # msg = str('msg')

类型转换：str可以把任意其他类型都转成字符串

res = str({'a': 1})
print(res, type(res))  # {'a': 1} <class 'str'>

内置方法：Python的字符串是不可变类型，所以通过内置方法得到的字符串并不是改变了原字符串，而是产生了新的字符串。

1. 按索引取值(正向取+反向取) ：只能取不能改

msg = 'hello world'
# 正向取
print(msg[0])  # h
print(msg[5])  # 空格
# 反向取
print(msg[-1])  # d

# 字符串按索引只能取值，若进行赋值操作则会报错
msg[0] = 'H'  # 程序报错

2. 切片：索引的拓展应用，从一个大字符串中 拷贝 出一个子字符串

msg = 'hello world'
# 要取到索引为4的字符结束的字符串，范围必须写到5
# 程序是“顾头(0)不顾尾(5)”
res = msg[0:5]
print(res)  # hello
print(msg)  # hello world

# 步长

res = msg[0:5:2]  # 0 2 4
print(res)  # hlo

# 反向步长

res = msg[5:0:-1]
print(res)  # " olle"

print(msg[0:5:-1])  # 空
# 0:5的意思为从左往右，-1是从右往左
# 相当于要求人要往前走，但腿必须往后迈，是一件相悖的事情，所以结果为空。

print(msg[5:0])  # 空
# 步长不写默认为1，程序相当于print(msg[5:0:1]),与上面是一个道理，所以结果为空。要想正常输出，步长也应该更改为-1。

# 反转字符串

msg = 'hello world'
res = msg[::-1]
print(res)  # dlrow olleh

# 步长为正，从左至右。头位不写默认0，尾位不写默认为全；
# 步长为负，从右至左。头位不写默认为全，尾位不写默认为全。

msg = 'hello world'

res0 = msg[:5]
print(res0)  # hello

res1 = msg[0:]
print(res1)  # hello world

res2 = msg[:5:-1]
print(res2)  # dlrow

res3 = msg[4::-1]
print(res3)  # olleh

# 步长为负，尾位写0时，取不到0号字符。“顾头不顾尾”
res4 = msg[4:0:-1]
print(res4)  # olle

# 字符串是不可变类型，通过内置方法得到的字符串并不是改变了原字符串，而是产生了新的字符串，那这里的id为什么还是一样的？

msg1 = 'hello:world:<>:19[]==123'
msg2 = msg1[:]
print(msg1, id(msg1))
# hello:world:<>:19[]==123 1271272885104
print(msg2, id(msg2))
# hello:world:<>:19[]==123 1271272885104

# 通过[:]的方法，等于是拷贝了整个字符串。
# 取字符串是为了读(因为不能改)，没有必要生成和原字符串一模一样的新字符串，所以[:]得到的字符串并不是新生成的，还是原来的字符串。

3. 长度len

# 统计字符个数

msg = 'hello world'
print(len(msg))  # 11

4. 成员运算in和not in

# 判断一个子字符串是否存在于一个大字符串中

print("hello" in "hello world")  # True
print("hello" not in "hello world")  # False 推荐使用
print(not "hello" in "hello world")  # False 不推荐使用

5. 移除字符串左右两侧的符号strip

# 默认去掉的是空格

msg = '      abcd      '
res = msg.strip()
print(msg) # 不会改变原值  “      abcd      ”
print(res) # 是产生了新值  “abcd”

# 想去掉什么符号，在strip()中写入这个符号即可。

msg = '****abcd****'
print(msg.strip('*'))  # abcd

# strip只去两边，不去中间

msg = '****a*****bcd****'
print(msg.strip('*'))  # a*****bcd

# 去掉多种符号，在strip()中可以不按顺序的写入要去掉的符号即可。

msg = '**/*===-**abcd**---/-=()**'
print(msg.strip('*/-=()'))  # abcd

# 小例子：清除用户误触输入空格的影响

inp_user = input('your name>>: ').strip()
inp_pwd = input('your password>>: ').strip()
if inp_user == 'admin' and inp_pwd == '123':
    print('登录成功')
else:
    print('账号密码错误')

6. 切分split：把一个字符串按照某种分隔符进行切分，得到一个列表

# 默认分隔符是空格

info = 'Python JavaScript Golang'
res = info.split()
print(res)  # ['Python', 'JavaScript', 'Golang']

# 指定分隔符

info = 'Python、JavaScript、Golang'
res = info.split('、')
print(res)  # ['Python', 'JavaScript', 'Golang']

# 指定分隔次数

info = 'Python:JavaScript:Golang'
res = info.split(':', 1)  # 分隔1次
print(res)  # ['Python', 'JavaScript:Golang']

7. 循环

info = 'Python:JavaScript:Golang'
for x in info:
    print(x, end=',')

# P,y,t,h,o,n,:,J,a,v,a,S,c,r,i,p,t,:,G,o,l,a,n,g,

8. strip，lstrip，rstrip

msg = '***abcd****'
# 移除两侧符号 详细用法见上方5。
print(msg.strip('*'))  # abcd
# 移除左侧符号
print(msg.lstrip('*'))  # abcd****
# 移除右侧符号
print(msg.rstrip('*'))  # ***abcd

9. lower，upper

msg = 'AbbbCCCC'
print(msg.lower())  # abbbcccc 将字符串中的大写字母转成小写字母
print(msg.upper())  # ABBBCCCC 将字符串中的小写字母转成大写字母

10. startswith，endswith

print("alex is sb".startswith("alex"))  # True 判断字符串是否以指定字符(串)开头
print("alex is sb".endswith('sb'))  # True 判断字符串是否以指定字符(串)结尾

11. format

（1）按位置传值：

res = '我的名字是 {} 我的年龄是 {}'.format('JL',19)
print(res)
# 我的名字是 JL 我的年龄是 19

res='我的名字是 {0}{0}{0} 我的年龄是 {1}{1}'.format('JL',19)
print(res)
# 我的名字是 JLJLJL 我的年龄是 1919

（2）打破位置的限制，按照 key = value 传值：

res="我的名字是 {name} 我的年龄是 {age}".format(age=19,name='JL')
print(res)
# 我的名字是 JL 我的年龄是 19

12. split，rsplit：将字符串切成列表

? split见上方“6.切分split”

info = "Python:JavaScript:Golang"
# split按照从左往右的顺序切分
print(info.split(':', 1))  # ['Python', 'JavaScript:Golang']
# rsplit按照从右往左的顺序切分
print(info.rsplit(':', 1))  # ['Python:JavaScript', 'Golang']

13. join：把列表拼接成字符串

l = ['Python', 'JavaScript', 'Golang']

res0 = l[0] + ":" + l[1] + ":" + l[2]
print(res0)  # Python:JavaScript:Golang

res = ":".join(l)  # 按照某个分隔符号，把元素全为字符串的列表拼接成一个大字符串
print(res)  # Python:JavaScript:Golang

l = [1, "2", 'aaa']
res = ":".join(l)  # 程序报错

14. replace

msg = "you can you up no can no bb"

# 三个参数，第一个参数为要被替换的字符串，第二个参数为要替换成的字符串，第三个参数为替换次数，不写为全部。
print(msg.replace("you", "YOU", ))  # YOU can YOU up no can no bb
print(msg.replace("you", "YOU", 1))  # YOU can you up no can no bb

15. isdigit

# 判断字符串是否由纯数字组成，带除数字之外的任何符号都不行

print('123'.isdigit())  # True
print('12.3'.isdigit())  # False

# 应用案例

age = input('请输入你的年龄：').strip()
if age.isdigit():
    age = int(age)  # int("abbab")
    if age > 19:
        print('猜大了')
    elif age < 19:
        print('猜小了')
    else:
        print('才最了')
else:
    print('必须输入数字，傻子')

16. find，rfind，index，rindex，count

# 找到返回起始索引

msg = 'hello world of python '

print(msg.find('e'))  # 1 返回要查找的字符串在大字符串中的起始索引
print(msg.find('py'))  # 15

# find与index的功能和用法一样，唯一区别在于找不到时的情况
print(msg.index('o'))  # 4
print(msg.index('of'))  # 12

# 找不到

msg = 'hello world of python '

print(msg.find('xxx'))  # 返回-1，代表找不到
print(msg.index('xxx'))  # 程序报错

# count统计子字符(串)在大字符串中出现的次数

msg = 'Hello python hahaha,Bye java oh my god!'
print(msg.count('a'))  # 5
print(msg.count('ha'))  # 3

17. center，ljust，rjust，zfill

# 两个参数，第一个参数为指定字符串长度，第二个参数为补全所用符号

print('jl'.center(12, '*'))  # *****jl*****  长度12，'jl'居中，其余位置用'*'补全。
print('jl'.ljust(15, '*'))  # jl*************  左对齐
print('jl'.rjust(10, '*'))  # ********jl  右对齐

# 一个参数，为指定字符串长度，其余位置用'0'补全，内容右对齐。
print('jl'.zfill(10))  # 00000000jl

18. expandtabs

# '\n'代表换行的意思，'\t'代表制表符(空格)的意思。
# expandtabs()用来设置制表符代表的空格数

msg = 'hello\tworld'
print(msg.expandtabs(2))  # 设置制表符代表的空格数为2

19. captalize，swapcase，title

# 三个方法都无参数
# capitalize()：首字母大写；
# swapcase()：大小写反转，大写全变小写，小写全变大写；
# title()：每个单词的首字母大写。

print("hello world jl".capitalize())  # Hello world jl
print("Hello WorLd JL".swapcase())  # hELLO wORlD jl
print("hello world jL".title())  # Hello World Jl

20. is数字系列

# 判断是否为数字，数字分四种。

num1 = b'4'  # bytes
num2 = u'4'  # unicode,python3中无需加u就是unicode
num3 = '四'  # 中文数字
num4 = 'Ⅳ'  # 罗马数字

# isdigit只能识别：num1、num2
print(num1.isdigit()) # True
print(num2.isdigit()) # True
print(num3.isdigit()) # False
print(num4.isdigit()) # False


# isnumberic可以识别：num2(普通数字)、num3(中文数字)、num4(阿拉伯数字)
print(num2.isnumeric()) # True
print(num3.isnumeric()) # True
print(num4.isnumeric()) # True

# isdecimal只能识别：num2
print(num2.isdecimal())  # True
print(num3.isdecimal())  # False
print(num4.isdecimal())  # False

21. is其他

print('abc'.islower())  # 判断是否全为小写。
print('ABC'.isupper())  # 判断是否全为大写。
print('Hello World'.istitle())  # 判断是否各单词首字母大写。
print('123123aadsf'.isalnum())  # 判断字符串是否只由字母或数字组成，纯字母/纯数字/字母+数字。
print('ad'.isalpha())  # 判断字符串是否只由字母组成。
print('     '.isspace())  # 判断字符串是否只由空格组成。
print('print'.isidentifier())  # 判断标识符是否合法，python内置的标识符全部为合法。
print('age_of_tony'.isidentifier())  # 字母数字下划线组成，且开头不是数字，合法。
print('1age_of_tony'.isidentifier())  # 数字开头，不合法。

三、列表类型（有序）

作用：按位置存放多个值

类型转换：但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表

res = list('hello')
print(res)  # ['h', 'e', 'l', 'l', 'o']

res = list({'k1': 111, 'k2': 222, 'k3': 3333})
print(res)  # ['k1', 'k2', 'k3']

内置方法

1. 按索引存取值(正向存取+反向存取)：即可以取也可以改

   l = [111, 'world', 'hello']
   
   # 正向取
   print(l[0])  # 111
   # 反向取
   print(l[-1])  # hello
   
   # 可以取也可以改：索引存在则修改对应的值
   l[0] = 222
   print(l)  # [222, 'world', 'hello']
   
   # 无论是取值操作还是赋值操作：索引不存在则报错
   l[3] = 333  # 程序报错
   

2. 切片(顾头不顾尾，步长)

   l = [111, 'world', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
   
   print(l[0:3])  # [111, 'world', 'hello']
   print(l[0:5:2])  # 0 2 4 [111, 'hello', 'b']
   
   print(l[0:len(l)])  # [111, 'world', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
   print(l[:])  # [111, 'world', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
   
   new_l = l[:]  # 切片等同于拷贝行为，而且相当于浅copy
   print(id(l))  # 2268740252288
   print(id(new_l))  # 2268740082368
   l[-1][0] = 1111111
   print(l)  # [111, 'world', 'hello', 'a', 'b', 'c', 'd', [1111111, 2, 3]]
   print(new_l)  # [111, 'world', 'hello', 'a', 'b', 'c', 'd', [1111111, 2, 3]]  可以看到new_l也发生了变化
   
   # 列表反转倒序
   print(l[::-1])  # [[1111111, 2, 3], 'd', 'c', 'b', 'a', 'hello', 'world', 111]
   

3. 长度

   print(len([1, 2, 3]))  # 3
   

4. 成员运算in和not in

   print('aaa' in ['aaa', 1, 2])  # True
   print(1 in ['aaa', 1, 2])  # True
   print(3 not in ['aaa', 1, 2])  # True
   

5. 往列表中添加值

   追加

   l = [111, '222', 'hello']
   l.append(3333)
   print(l)  # [111, '222', 'hello', 3333]
   l.append(4444)
   print(l)  # [111, '222', 'hello', 3333, 4444]
   

   指定位置插入值

   l = [111, 'JavaScript', 'Golang']
   l.insert(0, 'Python')  # (索引, 插入值)
   print(l)  # ['Python', 111, 'JavaScript', 'Golang']
   l.insert(0, 1)
   print(l)  # [1, 'python', 111, 'JavaScript', 'Golang']
   

   l.extend()

   # 列表后面追加另一个列表的全部元素
   
   new_l = [1, 2, 3]
   l = [111, 'Python', 'JavaScript']
   l.append(new_l)
   print(l)  # [111, 'Python', 'JavaScript', [1, 2, 3]]  结果不对，插入的直接是整个列表
   

   # 使用for循环可以实现
   
   new_l = [1, 2, 3]
   l = [111, 'Python', 'JavaScript']
   
   for item in new_l:
       l.append(item)
   print(l)  # [111, 'Python', 'JavaScript', 1, 2, 3]
   

   # extend直接实现上述代码
   
   l.extend(new_l)
   print(l)  # [111, 'Python', 'JavaScript', 1, 2, 3]
   l.extend('abc')
   print(l)  # [111, 'Python', 'JavaScript', 1, 2, 3, 'a', 'b', 'c']
   

6. 删除

   方式一：通用的删除方法，只是单纯的删除、没有返回值

   l = [111, 'world', 'hello']
   del l[1]
   # x = del l[1]  # 程序报错，不支持赋值语法(没有返回值)
   print(l)  # [111, 'hello']
   

   方式二：l.pop()根据索引删除，会返回删除的值

   l = [111, 'world', 'hello']
   l.pop()  # 不指定索引默认删除最后一个
   l.pop()
   print(l)  # [111]
   

   l = [111, 'world', 'hello']
   res = l.pop(1)
   print(l)  # [111, 'hello']
   print(res)  # world
   

   方式三：l.remove()根据元素删除，返回None(主观上相当于无返回值)

   l = [111, 'world', [1, 2, 3], 'hello']
   
   l.remove([1, 2, 3])
   print(l)  # [111, 'world', 'hello']
   
   res = l.remove('world')
   print(res)  # None
   print(l)  # [111, 'hello']
   

7. 循环

   l = [1, 'aaa', 'bbb']
   for x in l:
       print(x)
       
   # 结果
   # 1
   # aaa
   # bbb
   

8. l.copy

   见“Python学习_ 基础 _05_if条件判断、列表的深浅copy：三、2. a. 浅copy”

9. l.count()

   # 元素在列表中的出现次数
   
   l = [1, 'aaa', 'bbb', 'aaa', 'aaa']
   print(l.count('aaa'))  # 3
   

10. l.index()

    # 查找指定元素在列表中第一次出现的位置，列表没有find()方法，只有index()方法。
    
    l = [1, 'aaa', 'bbb', 'aaa', 'aaa']
    print(l.index('aaa'))  # 1
    print(l.index('aaaaaaaaa'))  # 找不到报错
    

11. l.clear()

    # 清空列表中所有的元素
    
    l = [1, 'aaa', 'bbb', 'aaa', 'aaa']
    l.clear()  # 无参数
    print(l)  # []
    

12. l.reverse()：不是排序，而是将列表倒过来(反转)

    l = [1, 'PY', 'JS', 'GO']
    l.reverse()  # 无参数
    print(l)  # ['GO', 'JS', 'PY', 1]
    

13. l.sort(): 列表内元素必须是同种类型才可以排序，不然会报错

    l = [11, -3, 9, 2, 3.1]
    l.sort()  # 默认从小到大排，称之为升序  l.sort(reverse=False)
    print(l)  # [-3, 2, 3.1, 9, 11]
    
    l.sort(reverse=True)  # 从大到小排，设置为降序
    print(l)  # [11, 9, 3.1, 2, -3]
    
    l = ['c', 'e', 'a']
    l.sort()
    print(l)  # ['a', 'c', 'e']
    

    字符串可以比大小，按照对应的位置的字符依次pk，直到比出胜负。

    字符的大小是按照ASCI码表的先后顺序加以区别，表中排在后面的字符大于前面的。

    print('a' > 'b')  # False
    print('abz' > 'abcdefg')  # True
    

    列表也可以比大小，原理同字符串一样依次pk，但是对应位置的元素必须是同种类型。

    l1 = [1, 'abc', 'zaa']
    l2 = [1, 'abc', 'zb']
    
    print(l1 < l2)  # True
    

列表实现队列与堆栈

1. 队列：FIFO(First In, First Out)，先进先出

   l=[]
   # 入队操作
   
   l.append('first')
   l.append('second')
   l.append('third')
   
   print(l)  # ['first', 'second', 'third']
   

   # 出队操作
   
   print(l.pop(0))  # first
   print(l.pop(0))  # second
   print(l.pop(0))  # third
   

2. 堆栈：LIFO(Last In, First Out)，后进先出

   l=[]
   # 入栈操作
   
   l.append('first')
   l.append('second')
   l.append('third')
   print(l)  # ['first', 'second', 'third']
   

   # 出栈操作
   
   print(l.pop())  # third
   print(l.pop())  # second
   print(l.pop())  # first
   

四、元组类型(就是一个“不可变的列表”，有序，属于不可变类型)

作用：按照索引/位置存放多个值，只用于读不用于改

定义：（ ）内用逗号分隔开多个任意类型的元素j

t = (1, 1.3, 'aa')  # t=tuple((1,1.3,'aa'))
print(t, type(t))  # (1, 1.3, 'aa') <class 'tuple'>

t = (10,)  # 如果元组中只有一个元素，必须加逗号
print(t, type(t))  # (10,) <class 'tuple'>

x = (10)  # 单独一个括号代表包含的意思
print(x, type(x))  # 10 <class 'int'>

# 元组的元素不能被更改，没有更改操作。
# 从本质上讲，是元组内元素的内存地址不能发生变化。若元组内有元素是可变类型，值发生变化内存而地址不发生变化，这种情况可以更改。

t = (1, 1.3, 'aa')  # t=(0->值1的内存地址,1->值1.3的内存地址,2->值'aaa'的内存地址，)
# t[0] = 11111  程序报错

t = (1, [11, 22])  # t=(0->值1的内存地址,1->值[11,22]的内存地址，)
print(id(t[0]), id(t[1]))  # 140711415256736 1630339462720

# t[0] = 111111111 # 不能改
# t[1] = 222222222 # 不能改

t[1][0] = 11111111111111111
print(t)  # (1, [11111111111111111, 22])
print(id(t[0]), id(t[1]))  # 140711415256736 1630339462720

类型转换：

# 使用tuple()进行转换，变为元组类型

print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')
print(tuple([1, 2, 3]))  # (1, 2, 3)
print(tuple({'a1': 111, 'a2': 333}))  # ('a1', 'a2')

内置方法：

1. 按索引取值（正向取+反向取）：只能取

   t = ('aa', 'bbb', 'cc')
   print(t[0])  # aa
   print(t[-1])  # cc
   

2. 切片（顾头不顾尾，步长）（切片是一种拷贝操作）

   t = ('aa', 'bbb', 'cc', 'dd', 'eee')
   print(t[0:3])  # ('aa', 'bbb', 'cc')
   print(t[::-1])  # ('eee', 'dd', 'cc', 'bbb', 'aa')
   

3. 长度

   t = ('aa', 'bbb', 'cc', 'dd', 'eee')
   print(len(t))  # 5
   

4. 成员运算in和not in

   t = ('aa', 'bbb', 'cc', 'dd', 'eee')
   print('aa' in t)  # True
   

5. 循环

   t = ('aa', 'bbb', 'cc', 'dd', 'eee')
   for x in t:
       print(x)
   # aa
   # bbb
   # cc
   # dd
   # eee
   

6. index()

   t = (2, 3, 111, 111, 111, 111)
   print(t.index(111))  # 2
   #print(t.index(1111111111))  # 找不到，报错
   

7. count()

   t = (2, 3, 111, 111, 111, 111)
   print(t.count(111))  # 4
   

五、字典类型（无序）

定义：{ }内用逗号分隔开多个 key：value，其中 value 可以使任意类型，但是 key 必须是不可变类型，且不能重复。

造字典的方式一：

d = {'k1': 111, (1, 2, 3): 222}  # d=dict(...)
print(d['k1'])  # 111
print(d[(1, 2, 3)])  # 222
print(type(d))  # <class 'dict'>

d = {}  # 默认定义出来的是空字典
print(d, type(d))  # {} <class 'dict'>

造字典的方式二：

d = dict(x=1, y=2, z=3)
print(d, type(d))  # {'x': 1, 'y': 2, 'z': 3} <class 'dict'>

造字典的方式三：快速初始化一个字典

# 字典的key值分别对应列表元素，值全为None

keys=['name','age','gender']
# d={}
# for k in keys:
#     d[k]=None
# print(d)  # {'name': None, 'age': None, 'gender': None}
d={}.fromkeys(keys,None) # 一行代码搞定上述for循环的工作
print(d)  # {'name': None, 'age': None, 'gender': None}



# fromkeys()对字典进行初始化，不一定非是None，写其他不可变类型也是可以的。
# fromkeys()产生的是一个新的字典,必须要用一个变量名接住。
# 初始化值要用不可变类型，实际情况是所有的值都来自同一个地方，id都是相同的。对其中一个进行更改，直接改变绑定关系，所以影响不大。
# 切记不要用可变类型，如果用了，对其中一个进行更改，所有的值都会发生改变。

keys = ['a', 'b', 'c', 'd']
d = {}

d = d.fromkeys(keys, 10)
print(d, '\n', id(d['a']), id(d['b']), id(d['c']))
# {'a': 10, 'b': 10, 'c': 10, 'd': 10} 
#  140711063066560 140711063066560 140711063066560

d = d.fromkeys(keys, '字母')
print(d, '\n', id(d['a']), id(d['b']), id(d['c']))
# {'a': '字母', 'b': '字母', 'c': '字母', 'd': '字母'} 
#  2234263779728 2234263779728 2234263779728

d = d.fromkeys(keys, [1, 2, 3, 4])
d['a'][0] = 99
print(d)  # {'a': [99, 2, 3, 4], 'b': [99, 2, 3, 4], 'c': [99, 2, 3, 4], 'd': [99, 2, 3, 4]}

数据类型转换

info = [
    ['name', '李白'],
    ('age', 18),
    ['gender', 'male']
]

# 使用循环进行数据类型转换
d = {}
for x in info:
    d[x[0]] = x[1]  # x第一次取的是 ['name', '李白']
print(d)  # {'name': '李白', 'age': 18, 'gender': 'male'}

# 对上面的代码进行优化
d = {}
for k, v in info:  # 第一次为：k,v=['name','李白'] 循环相当于进行三次解压赋值
    d[k] = v
print(d)  # {'name': '李白', 'age': 18, 'gender': 'male'}

# dict()就相当于做了上面的事情
res = dict(info)  # 一行代码搞定上述for循环的工作
print(res)

内置方法

1. 按key存取值：可存可取

   d = {'k1': 111}
   
   # 针对赋值操作：key存在，则修改
   d['k1'] = 222
   
   # 针对赋值操作：key不存在，则创建新值
   d['k2'] = 3333
   
   print(d)  # {'k1': 222, 'k2': 3333}
   

2. 长度len

   d = {'k1': 111, 'k2': 2222, 'k1': 3333, 'k1': 4444}
   print(d)  # {'k1': 4444, 'k2': 2222}
   print(len(d))  # 2
   

3. 成员运算in和not in：根据key

   d = {'k1': 111, 'k2': 2222}
   print('k1' in d)  # True
   print(111 in d)  # False
   

4. 删除

   4.1 通用删除

   d = {'k1': 111, 'k2': 2222}
   del d['k1']
   print(d)  # {'k2': 2222}
   

   4.2 pop删除：根据key删除元素，返回删除key对应的那个value值

   d = {'k1': 111, 'k2': 2222}
   res = d.pop('k2')
   print(d)  # {'k1': 111}
   print(res)  # 2222
   

   4.3 popitem删除：随机删除(不是从末尾删除，因为字典无序)，返回元组(删除的key,删除的value)

   d = {'k1': 111, 'k2': 2222}
   res = d.popitem()
   print(d)  # {'k1': 111}
   print(res)  # ('k2', 2222)
   

5. 键keys()，值values()，键值对items() =>在python3中得到的是老母鸡(为了节省空间)

   '''
   在python2中：
   d.keys()得到的是一个由字典全部key组成的列表；
   d.values()得到的是一个由字典全部key的值(value)组成的列表；
   d.items()得到的是一个由字典(key,value)组成的一个个元组所组成的列表。
   
   >>> d={'k1':111,'k2':2222}
   >>> 
   >>> d.keys()
   ['k2', 'k1']
   >>> d.values()
   [2222, 111]
   >>> d.items()
   [('k2', 2222), ('k1', 111)]
   >>>
   '''
   
   # 在python3中：
   d = {'k1': 111, 'k2': 2222}
   print(d.keys())  # dict_keys(['k1', 'k2'])
   print(d.values())  # dict_values([111, 2222])
   print(d.items())  # dict_items([('k1', 111), ('k2', 2222)])
   

   ? 让老母鸡下蛋的方法看下面“6. for循环”

6. for循环

   d = {'k1': 111, 'k2': 2222}
   
   #for k in d.keys():
   #    print(k)  # k1  k2
   # 可以用d直接替代d.keys()
   
   for k in d:
       print(k)  # k1  k2
   
   for v in d.values():
       print(v)  # 111  2222
       
   for item in d.items():
       print(item)  # ('k1', 111)  ('k2', 2222)  取出来的是元组
   
   for k, v in d.items():  # 利用解压赋值
       print(k, v)  # k1 111  k2 2222
   
   # 使用list()直接转换成列表
   print(list(d.keys()))  # ['k1', 'k2']
   print(list(d.values()))  # [111, 2222]
   print(list(d.items()))  # [('k1', 111), ('k2', 2222)]
   

7. d.clear()（清空字典，结果为 { } ）

8. d.copy()（相当于浅拷贝）

9. d.update()

   d = {'k1': 111, 'k2': 2222}
   d.update({'k2': 222, 'k3': 333, 'k1': 88888})
   print(d)  # {'k1': 88888, 'k2': 222, 'k3': 333}
   

10. d.get()：根据key取值，容错性好

    d = {'k1': 111, 'k2': 2222}
    # print(d['k3'])  # key不存在则报错
    
    print(d.get('k1'))  # 111
    print(d.get('k3'))  # key不存在不报错，而是返回None
    
    
    # d.get()的自定义返回值用法
    
    d = {'k1': 111, 'k2': 2222}
    res0 = d.get('k1', '空空如也')
    res1 = d.get('k3', '空空如也')
    print(res0)  # 111   存在即返回对应value值
    print(res1)  # 空空如也  不存在即返回自定义值
    

11. d.setdefault()：有则不改，无则添加

    # 常规方法实现
    
    info = {}
    if 'name' in info:
        pass  # 什么都不执行(执行空语句)，也可以写成 ... ，效果等同于pass，但这个位置不能不写代码
    else:
        info['name'] = 'Python'
    print(info)  # {'name': 'Python'}
    

    # 如果key已有则不添加（不更改），返回字典中key对应的值
    
    info = {'name': 'JS'}
    res = info.setdefault('name', 'PY')
    print(res)  # JS
    print(info)  # {'name': 'JS'}
    

    # 如果key没有则添加，返回字典中key对应的值
    
    info = {}
    res = info.setdefault('name', 'GO')
    print(res)  # GO
    print(info)  # {'name': 'GO'}
    

六、集合类型

? 在学习集合类型之前，先思考一个简单的问题，怎样得到具有重合元素的两个列表的交集(重合)部分？且得到的部分用新列表表示。

# 用一个新的列表输出下面两个列表的重合部分

friends1 = ["zero", "kevin", "jason", "egon"]
friends2 = ["Jy", "ricky", "jason", "egon"]

l = []
for x in friends1:
    if x in friends2:
        l.append(x)
print(l)  # ['jason', 'egon']

定义：

定义集合的三大注意：

1. 集合内元素必须为不可变类型
2. 集合内元素无序
3. 集合内元素没有重复

s = {1, 2}  # s=set({1,2})

# s = {1, [1, 2]}  # 程序报错  集合内元素必须为不可变类型
s = {1, 'a', 'z', 'b', 4, 7}  # 集合内元素无序
s = {1, 1, 1, 1, 1, 1, 'a', 'b'}  # 集合内元素没有重复
print(s)  # {1, 'a', 'b'}

s = {}  # 默认是空字典
print(type(s))  # <class 'dict'>

# 定义空集合
s = set()
print(s, type(s))  # set() <class 'set'>

类型转换：

# 进行类型转换时，要切记定义集合的三大注意。
# 别忘记，集合可以通过列表的类型转换list()转成列表，这也是很常见的情况。

res = set('hellolllll')

print(res)  # {'h', 'l', 'e', 'o'}

print(set([1, 1, 1, 1, 1, 1]))  # {1}

# print(set([1, 1, 1, 1, 1, 1, [11, 222]])  # 报错

print(set({'k1': 1, 'k2': 2}))  # {'k2', 'k1'}

内置方法：关系运算、去重

1. 取交集：两者共同的好友

   friends1 = {"zero", "kevin", "jason", "egon"}
   friends2 = {"Jy", "ricky", "jason", "egon"}
   
   res = friends1 & friends2
   print(res)  # {'jason', 'egon'}
   
   # 也可使用内置方法
   # print(friends1.intersection(friends2))
   

2. 取并集/合集：两者所有的好友

   friends1 = {"zero", "kevin", "jason", "egon"}
   friends2 = {"Jy", "ricky", "jason", "egon"}
   
   print(friends1 | friends2)
   #{'jason', 'kevin', 'egon', 'zero', 'Jy', 'ricky'}
   
   # 也可使用内置方法
   # print(friends1.union(friends2))
   

3. 取差集：取friends1独有的好友、取friends2独有的好友

   friends1 = {"zero", "kevin", "jason", "egon"}
   friends2 = {"Jy", "ricky", "jason", "egon"}
   
   # 取friends1独有的好友
   print(friends1 - friends2)  # {'zero', 'kevin'}
   
   # 也可使用内置方法
   # print(friends1.difference(friends2))
   
   #-------------------------------------------------------------#
   
   # 取friends2独有的好友
   print(friends2 - friends1)  # {'ricky', 'Jy'}
   
   # 也可使用内置方法
   #print(friends2.difference(friends1))
   

4. 取对称差集: 求两个用户独有的好友们（即各种去掉共有的好友然后取并集）

   friends1 = {"zero", "kevin", "jason", "egon"}
   friends2 = {"Jy", "ricky", "jason", "egon"}
   
   # print((friends1 - friends2)|(friends2 - friends1))
   print(friends1 ^ friends2)  # {'Jy', 'zero', 'ricky', 'kevin'}
   
   # 也可使用内置方法
   # print(friends1.symmetric_difference(friends2))
   

5. 父子集：包含与被包含的关系

   s1 = {1, 2, 3}
   s2 = {1, 2, 4}
   # 不存在包含关系，下面两个比较均为False
   print(s1 > s2)  # False
   print(s1 < s2)  # False
   
   s1 = {1, 2, 3}
   s2 = {1, 2}
   print(s1 > s2)  # True  当s1大于或等于s2时，才能说是s1是s2他爹
   # print(s1.issuperset(s2))  # True
   # print(s2.issubset(s1))  # s2 < s1  =>True
   
   s1 = {1, 2, 3}
   s2 = {1, 2, 3}
   print(s1 == s2)  # True  s1与s2互为父子
   # print(s1.issuperset(s2))  # True
   # print(s2.issuperset(s1))  # True
   

6. 长度

   s = {'a', 'b', 'c'}
   print(len(s))  # 3
   

7. 成员运算

   s = {'a', 'b', 'c'}
   print('a' in s)  # True
   print('b' not in s)  # False
   

8. 循环

   s = {'a', 'b', 'c'}
   for item in s:
       print(item)
       
   # b
   # c
   # a
   

9. discard()

   # 删除元素，存在就删除，不存在就do nothing
   s = {1, 2, 3}
   s.discard(3)
   print(s)  # {1,2}
   
   # remove()也是删除，不过当元素不存在时就会报错
   # s.remove(4)  # 程序报错
   

10. update()

    # 更新集合
    s = {1, 2, 3}
    s.update({1,3,5})
    print(s)  # {1, 2, 3, 5}
    

11. pop()

    # 随机删除，并返回删除的值
    res = s.pop()
    print(res)
    

12. add()

    # 添加元素
    s.add(66)
    print(s)
    

13. 两个了解的方法

    s = {1, 2, 3}
    res = s.isdisjoint({3, 4, 5, 6})  # 两个集合完全独立、没有共同部分，返回True
    print(res)  # False
    
    s.difference_update({3, 4, 5})  # s = s.difference({3,4,5})
    # 取s相对于集合{3, 4, 5}独有的部分，再覆盖赋值给s自己
    print(s)  # {1, 2}
    

集合可以去重，但是有局限性。

1. 只能针对不可变类型去重

   print(set([1,1,1,1,2]))  # {1, 2}
   

2. 无法保证原来的顺序

   l = [1, 'a', 'b', 'z', 1, 1, 1, 2]
   l = list(set(l))
   print(l)  # 每一次都是随机顺序  ['b', 1, 'z', 2, 'a']
   

利用循环对可变类型进行去重，而且保留顺序：

l = [
    {'name': 'lili', 'age': 18, 'sex': 'male'},
    {'name': 'jack', 'age': 73, 'sex': 'male'},
    {'name': 'tom', 'age': 20, 'sex': 'female'},
    {'name': 'lili', 'age': 18, 'sex': 'male'},
    {'name': 'lili', 'age': 18, 'sex': 'male'},
]
new_l = []
for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print(new_l)

总结：

本文参考文章：https://zhuanlan.zhihu.com/p/108793771