python数据类型学习笔记

字符串的用法

一、字符串的表示方法

1. 在python里可以使用一对单引号，一对双引号或者一对三个双引号、一对三个单引号

   a = 'hello'
   b = "good"
   c = """哈哈哈"""
   d = '''呵呵呵'''
   # 如果字符串里还有双引号，外面就可以使用单引号
   m = " xiaoming said":"I'm xiaoming"
   

2. 字符串里的转义字符 \

   \" ==> 显示一个普通的双引号

   \n ==> 表示一个换行

   \t ==> 表示显示一个制表符

   \\ ==> 表示一个普通的反斜线

   在字符传前面添加 r ® 在python里表示的是原生字符串

   x = 'I\'m xiaoming'  # \表示的是转义字符，作用是对\后面的字符进行转义
   y = "xiaoming said:\"I am xiaoming\""
   z = 'hello \n world'
   x1 = r'hello \teacher'
   

二、字符串的下标和切片

1. 下标又称之为索引，表示第几个数据

2. 可迭代对象：str 、list 、 tuple 、dict 、set 、 range ，都可以进行遍历

   str 、list 、tuple 可以通过下标来获取或者操作数据

3. 在计算机里，下标都是从 0 开始的

4. 字符串是不可变的数据类型，对于字符串的任何操作，都不会改变原有的字符串！！！

5. 切片：就是从字符串里复制一段指定的内容，生成一个新的字符串

   m = 'abcdefghijklmnopqrstuvwxyz'
   print(m[5])  # 打印 'f'
   

   切片的语法：m[start:end :step]，包含start，不包含end，step指步长，每隔step-1个取一个，step为负数，表示从右往左获取

   print(m[2:9])  # 打印'cdefghi' 包含start，不包含end
   print(m[2:])  # 如果只设置了start，会“截取”到最后
   print(m[:9])  # 打印 'abcdefghi' ，如果只设置了end，会从头开始“截取”
   # 步长默认为1
   print(m[3:15:2])  # 'dfhjln'
   print(m[3:15:1])  # 'abcdefjhigklmn'
   print(m[3:15:0])  # 会报错，步长不能为0
   print(m[3:15:-1])  # 没有数据，从d开始，往左找，没有索引为15的数，找不到就是空
   print(m[15:3:-1])  # 'ponmlkjihgfe'
   
   print(m[::])  # 从头到尾复制 'abcdefghijklmnopqrstuvwxyz'
   print(m[::-1])  # 从右往左复制 'zyxwvutsrqponmlkjihgfedcba'
   
   print(m[-5:-9])  # 返回空
   print(m[-9:-5])  # 'rstu'，往左数第9个数，到往左数第5个数（不包含第5个），方向由步长step控制，默认从左往右
   

三、字符串的常见操作（方法）

字符串常见的操作包括：

• 获取长度：len

• 查找内容：find，index，rfind，rindex

• 判断：startswith，endswith，isalpha，isdigit，isalnum，isspace，isdecimal，islower，isupper，istitle

• 计算出现的次数：count

• 替换内容：replace

• 切割字符串：split，rsplit，splitlines，partition，rpartition

• 修改大小写：capitalize，title，upper，lower，swapcase

• 空格处理：ljust，rjust，center，lstrip，rstrip，strip，zfill

• 字符串拼接：join

• 字符串的运算符：+，*，==，!=

• 字符串的编码与解码：encode，decode

• 成员运算符： in，not in

• 字符串的格式化：format

  注意：在python中，字符串是不可变的！所有的字符串相关方法，都不会改变原有的字符串，都是返回一个结果，在这个新的返回值里，保留了执行后的结果！

1、字符串的查找

x = 'abcdefghijklmn'

# 使用内置函数 len 可以获取字符串的长度
print(len(x))  # 14

• 查找内容相关的方法 find/index/rfind/findex 可以获取指定字符的下标
• find语法：str.find(substr,start,end) #substr为子串，start，end可选，指明查找的位置
• index语法：str.index(substr,start,end)

print(x.find('l'))  # 11
print(x.index('l'))  # 11

print(x.find('p'))  # -1 如果字符在字符串里不存在，结果是-1
print(x.index('p'))  # 使用index，如果字符不存在，会报错
print(x.find('l', 4, 9))  # 从第4个找到第9个，没找到，返回-1
print(x.rfind('l'))  # 从右往左找，返回找到的第一个值的索引，返回 11
print(x.rindex('l'))  # 从右往左找，返回找到的第一个值的索引，返回 11

2、字符串的判断

• startswith,endswith,isalpha,isdigit,isalnum,isspace,isupper,islower,istitle

• str.startswith(prefix, start, end) ：是否以指定字符串开始,start,end可选，指定判断的位置

• str.endswith(prefix,start,end) ：是否以指定字符串结束

• is开头的是判断，结果是一个布尔类型True/False

• str.isalpha() ： 是否全部字母

• str.isdigit() ： 是否全部数字

• str.isalnum() ： 是否全部字母或数字

• str.isspace() ：是否全部空格

• str.isdecimal()：是否全部十进制数

• str.isupper() ： 是否全部大写，非字母统一返回False

• str.islower() ：是否全部小写，非字母统一返回False

• str.istitle() ：是否首字母大写，其余小写

print('hello'.startswith('he'))  # True
print('hello'.endswith'o')  # True

print('he45llo'.isalpha())  # False  alpha字母

print('good'.isdigit())  # False，是否全部数字
print('123'.isdigit())  # True
print('3.14'.isdigit())  # False ，不能判断小数

print('ab12hello'.isalnum())  # True，是否全部字母或数字

print('   '.isspace())  # True  是否全部空格

3.字符串的替换和统计

• str.count(substr, start, end) # 统计子串出现的次数，start,end可选参数，指明统计的范围

mystr = '今天天气好晴朗，处处好风光啊好风光'
print(mystr.count('好', 0, 16))  # 在第1个到底16个之间，统计'好'出现的次数，3

• str.replace(oldstr, newstr, count)
• 用新字符替换字符串中对应字符，count可选参数，替换的次数，不传默认全部替换

word = 'hello'
print(word.replace('l', 'x'))  # 'hexxo'
print(word.replace('l', 'x', 1))  # 'hexlo'

4、内容分割相关的操作

• split , rsplit, splitlines, partition, rpartition
• str.split(sep, num) ： sep, num可选参数，sep是用于切割的字符，不传默认为空格，num为切割次数
• str.rsplit(sep, num) ： 从右往左切割
• str.splitlines(keepends) ： 按照行(‘\r’, ‘\r\n’, \n’)分隔，keepends可选参数，值为True或 False，True保留分割符，False不保留
• str.partition(str) ： 将字符串以指定字符分割为前端字符串、分割符、后端字符串三部分
• str.rpartiton(str) ： 从右往左找切割字符进行切割
• 使用split方法，可以将一个字符串切割成一个列表

x = 'zhang-lisi-wangwu-jerry'
print(x.split('-'))  # ['zhang', 'lisi', 'wangwu', 'jerry']
print(x.split('-', 2))  # ['zhang', 'lisi', 'wangwu-jerry']
print(x.rsplit('-', 2))  # ['zhang-lisi', 'wangwu', 'jerry'] 从右往左切割

• splitlines ：以换行符进行分割
• partition ：指定一个字符串作为分隔符，分为三部分，前面、分隔符、后面

print('abcdefxmpxqrst'.partition('x'))  # ('abcdef', 'x', 'mpxqrst')
print('abcdefxmpxqrst'.rpartition('x'))  # ('abcdefxmp', 'x', 'qrst')

# 获取文件名和后缀名
file_name = '好好的.mp4'
print('2021.3.14开始行动.mp4'.partition('.'))  # ('2021', '.', '3.14开始行动.mp4')
# 从左切会有问题，通常用从右往左切
print(file_name.rpartition('.'))  # ('好好的', '.', 'mp4')

5、修改大小写

• str.capitalize() ：将字符串第一个字母大写
• str.title() ：将字符串每个单词（空格分隔）的第一个字母大写
• str.upper() ：将字符串中的每个字母都变为大写
• str.lower() ：将字符串中的每个字母都变为小写
• str.swapcase() ：将字符串的大写字母变为小写，小写字母变为大写

s = 'hello world'
print(s.capitalize()) # 'Hello world'
print(s.title())  # 'Hello World'
print(s.upper())  # 'HELLO WORLD'
print('HEro'.lower())  # 'hero'
print('HEro'.swapcase())  # 'heRO'

# 判断输入
while True:
    content = input("请输入内容，输入exit退出：")
    if content.lower() == 'exit':
        break

6、空格处理

• str.strip(chars) ：去除字符串前面和后面的字符，chars可选参数，不传默认去除空格、换行、制表符

• str.rstrip(chars) ：去除字符串右边的字符，chars可选参数，不传默认去除空格、换行、制表符

• str.lstrip(chars) ：去除字符串左边的字符，chars可选参数，不传默认去除空格、换行、制表符

• str.ljust(width, fillchar) ：在指定长度内，原字符串左对齐，其余以指定字符填充，长度小于原字符串长度，返回原字符串，fillchar为可选参数，不传默认为空格

• str.rjust(width, fillchar) ：在指定长度内，原字符串右对齐，其余以指定字符填充，默认空格

• str.center(width, fillchar) ：在指定长度内，原字符串居中对齐，其余以指定字符填充，默认空格

• str.zfill(width) ：在指定长度内，原字符右对齐，其余以0填充

s = '  hello world \n\t  '
print(s.strip())  # 'hello world'
print('++hello world+++'.strip('+'))  # 'hello world'
print(s.rstrip())  # '  hello world'
print(s.lstrip())  # 'hello world \n\t  '

w = 'well' 
print(w.ljust(10))  # 'well      '
print(w.ljust(10, '*'))  # 'well******'
print(w.rjust(10))  # '      well'
print(w.center(10, '+'))  # '+++well+++'
print(w.zfill(10))  # '000000well'

7、拼接

• sep.join(sequence)
  sep指用于连接的字符，可为空，sequence为要拼接的序列，join方法是split方法的逆方法，返回拼接后的字符串

l = ['h', 'e', 'l', 'l', 'o', '123']
m = ('我', '爱', '你')
d = {'name':'lily', 'sex':'female', 'age':18}

print(''.join(l))  # 'hello123'
print('*'.join(l))  # 'h*e*l*l*o*123'
print(''.join(m))  # ‘我爱你’
print('-'.join(d))  # 'name-sex-age'

# 合并目录
import os
print(os.path.join('/user/','liming/desktop/','1.txt'))  # '/user/liming/desktop/1.txt'

8、运算符

• + 字符串与字符串之间使用加法运算，作用是拼接两个字符串
• * 字符串和数字之间使用乘法运算，作用是将制定字符串重复多次
• 字符串和数字之间做==运算结果是False，做!=运算，结果是True
• 字符串之间做比较运算，会逐个比较字符串的编码值
• 不支持其他运算

print('tom' + 'cat')  # 'tomcat'
print('good' * 3)  # 'goodgoodgood'
print('abc' == 1)  # False
print('12' != 12)  # True
print('abc' == 'abc')  # True

9、编码与解码

• str.encode(encoding, errors)
  按指定编码格式编码，errors可选，出错返回ValueError异常，encoding有：utf-8，gbk等，errors默认strict，还有ignore，replace等

• str.decode(encoding, errors)
  按指定编码格式解码，errors可选，出错返回ValueError异常，encoding有：utf-8，gbk等，errors默认strict，还有ignore，replace等

import base64

str = "this is string example....wow!!!"
str = base64.b64encode(str.encode('utf-8',errors = 'strict'))

print ("Encoded String: " , str)
# 结果： Encoded String: b'dGhpcyBpcyBzdHJpbmcgZXhhbXBsZS4uLi53b3chISE='

• GBK utf-8 BIG5
• gbk为国标扩，简体中文； BIG5大五码，繁体中文；utf-8统一编码
• 使用字符串的encode方法，可以将字符串转换成指定编码集结果
• 如果有一个编码集的结果，想把它转换成为对应的字符，使用decode

# GBK编码，一个汉字占两个字节
print('你'.encode('gbk'))  # b'\xc4\xe3'  50403  11000100 11100011

# utf8编码，一个汉字占三个字节  
print('你'.encode('utf8'))  # b'\xe4\xbd\xa0'  11100100 10111101 10100000

x = b'\xe4\xbd\xa0'
print(x.decode('utf-8'))  # '你'

# 乱码：编码和解码的编码格式不一致导致
y = '你好'.encode('utf8')  # utf8一个汉字转换成为三个字节
print(y)  # b' \xe4\xbd\xa0  \xe5\xa5\xbd'

print(y.decode('gbk'))  # '浣犲ソ'  \xe4\xbd  \xa0\xe5  \xa5\xbd
print(y.decode('utf8'))  # '你好'

10、成员运算符

• in 和 not in 运算符
• 用来判断一个内容在可迭代对象里是否存在

print('x' in 'hello')  # False
print('x' not in 'hello')  # True

11、格式化

• 可以使用 % 占位符来表示格式化一个字符串

name = 'liming'
age = 18
print('大家好，我的名字是', name, '我今年', age, '岁了', sep='')
# '大家好，我的名字是liming我今年18岁了'

• 在字符串里可以使用 % 占位符
• %s 表示的是字符串的占位符
• %d 表示的是整数的占位符
• %nd 打印时，显示n位，如果不够，在前面使用空格补齐
• %0nd 打印时，显示n位，如果不够，在前面使用0补齐
• %-nd 打印时，显示n位，如果不够，在后面使用空格补齐
• %f 表示的是浮点数的占位符
• %.nf 保留小数点后n位
• %x 将数字使用16进制输出
• %% 输出一个%

print('我排在第%3d位' % 3)  # '我排在第  3位'
print('我排在第%-3d位' % 3)  # '我排在第3  位'
print('我排在第%03d位' % 3)  # '我排在第003位'
print('我花了%.2f元钱' % 3.1415926)  # '我花了3.14元钱'
print('%x' % 255)  # ff

• {} 也可以进行占位
• {} 什么都不写，会读取后面的内容，一一对应填充

x = '大家好，我是{}，我今年{}岁了'.format('李明', 18)
print(x)  # '大家好，我是李明，我今年18岁了'
print('{:02d}:{:02d}:{:02d}'.format(9, 30, 0))  # '09:30:00'  自动补0

• {数字} 根据数字的顺序来进行填入，数字从0开始

y = '大家好，我是{1}，我今年{0}岁了'.format(16, 'lily')
print(y)  # '大家好，我是lily，我今年16岁了'

• {变量名}

m = '大家好，我是{name}，今年{age}，我来自{addr}'.format(age=18, name='amy', addr='海南')
print(m)  # '大家好，我是amy，今年18，我来自海南'

• 混合使用 {数字} {变量}

n = '大家好，我是{name}，我今年{1}岁了，我来自{0}'.format('北京', 24, name='tony')
print(n)  # '大家好，我是tony，我今年24岁了，我来自北京'

• {} 什么都不写 {数字} 不能混合使用

lst = ['liuxing', 18, '上海', 180]
# b = '大家好，我是{}，我今年{}岁了，我来自{}，身高{}cm'.format(lst[0], lst[1], lst[2], lst[3])
b = '大家好，我是{}，我今年{}岁了，我来自{}，身高{}cm'.format(*lst)
print(b)  # '大家好，我是liuxing，我今年18岁了，我来自上海，身高180cm'

info = {'name': 'lilei', 'age': 24, 'addr': '北京', 'height': 190}
c = '大家好，我是{name}，我来自{addr}，身高{height}cm，我今年{age}岁了'.format(**info)
print(c)  # '大家好，我是lilei，我来自北京，身高190cm，我今年24岁了'

python列表的使用

• 当有多个数据需要按照一定的顺序保存的时候，可以考虑列表

• 使用[]来表示一个列表，列表里的每一个数据称之为元素，元素之间使用逗号

• 和字符串一样，都可以使用下标来获取元素和对元素进行切片

• 同时，还可以使用下标来修改列表里的元素

• 列表是用来保存多个数据的，是有序可变的

• 操作列表，一般都包含增加数据、删除数据、修改数据、查询数据

names = ['赵云', '张飞', '关羽', '马超', '庞统', '黄忠']
print(names[3])  # '马超'
names[3] = '王昭君'
print(names) # ['赵云', '张飞', '关羽', '王昭君', '庞统', '黄忠']
print(names[1:3])  # ['张飞', '关羽']

1. 添加元素

• list.append(object) ：在列表最后面添加新的元素，object是要添加的元素
• list.insert(index, object)：在指定索引位置添加元素，index索引值，object元素
• list.extend(iterable)：在列表末尾一次性添加另一个序列中的多个值，iterable为可迭代对象

heros = ['阿珂', '嬴政', '韩信', '露娜', '后羿', '亚瑟']
heros.append('黄忠')
print(heros)  # ['阿珂', '嬴政', '韩信', '露娜', '后羿', '亚瑟', '黄忠']

heros.insert(3, '李白')
print(heros)  # ['阿珂', '嬴政', '韩信',  '李白', '露娜', '后羿', '亚瑟', '黄忠']

x = ['马可波罗', '米莱迪', '狄仁杰']
heros.extend(x)
print(heros)  # ['阿珂', '嬴政', '韩信', '李白', '露娜', '后羿', '亚瑟', '黄忠', '马可波罗', '米莱迪', '狄仁杰']
print(x)  # ['马可波罗', '米莱迪', '狄仁杰']

2. 删除元素

• list.pop(index)：index索引，可选参数，默认会删除列表里最后一个元素，并且返回这个数据
• list.remove(object)：删除列表中指定元素，object要删除的元素，如果元素在列表中不存在，会报错
• list.clear()：清空列表中的元素
• del list[1] : 删除

x = ['b', 'c', 'd', 'e', 'a']
# x.pop()  # ['b', 'c', 'd', 'e']
# x.pop(3)  # ['b', 'c', 'd', 'a']
# x.remove('c')  # ['b', 'd', 'e', 'a']
# x.remove(1)  # 报错 ValueError: list.remove(x): x not in list
x.clear()  # 清空列表，返回 []

3.查询

• list.index(value, start, end) ：查找value值第一个匹配项的索引位置，start、end可选，在指定位置开始查找
• list.count(value)：统计某个元素在列表出现的次数
• in：成员运算符，判断某个值是否在列表中，在列表中返回True，不在返回False

x = ['b', 'a', 'd', 'e', 'a']
x.index('a')  # 1
x.index('a', 2, 7)  # 4
x.index('f')  # 报错，未找到会报错
x.count('a')  # 2
print('d' in x)  # True

# for...in遍历元素，循环的本质是不断的调用跌大气的next方法查找下一个数据
for k in x:
    print(k)  # 逐一打印列表中元素 'b' 'a' 'd' 'e' 'a'

# while 循环遍历元素
i = 0
while i < len(x):
    print(x[i])
    i += 1

4.修改

• 使用下标可以直接修改列表里的元素

x = ['b', 'a', 'd', 'e', 'a']
x[2] = 'life'  
print(x)  # ['b', 'a', 'life', 'e', 'a']
x[7] = 'mongo'  # 会报错，索引超界

5. 排序

• list.sort(reverse=False) ：直接对原列表进行排序，reverse=False，不翻转，可选参数，默认为False

• sorted(list) ：内置函数，不会改变原有的列表数据，会生成一个新的有序列表数据

• list.reverse() ：将列表中的元素翻转

# 交换两个变量的值
a = 10
b = 20

# 方法一：使用第三方变量
# c = a
# a = b
# b = c

# 方法二：使用运算符来实现，只能是数字
# a = a + b
# b = a - b
# a = a - b
 
# 方法三：使用异或运算符
# a = a ^ b
# b = a ^ b
# a = a ^ b

# 方法四：使用python特有的方法
a, b = b, a

print(a)
print(b)

m = [6, 5, 3, 1, 8, 7, 2, 4]
m.sort()
print(m)  # [1, 2, 3, 4, 5, 6, 7, 8]

m.sort(reverse=True)
print(m)  # [8, 7, 6, 5, 4, 3, 2, 1]

n = sorted(m)
print(m)  # [6, 5, 3, 1, 8, 7, 2, 4]
print(n)  # [1, 2, 3, 4, 5, 6, 7, 8]

# m.reverse()
# print(m)  # [4, 2, 7, 8, 1, 3, 5, 6]

6、复制

• list.copy()：浅复制列表，和原列表的内容一样，但是指向不同的内存空间，不会相互影响

m = [100, 200, 300]
n = m.copy()  
print(n)  # [100, 200, 300]

x = m
m[0] = 1
print(x)  # [1, 200, 300]，可变数据类型，如果修改值，内存地址会发生变化

a = 16
b = a
a = 10
print(b)  # 16，不可变数据类型，如果修改值，内存地址不会发生变化，a会指向一个新的地址

# 使用copy模块
import copy
y = copy.copy(m)  # 等价于m.copy()，浅拷贝
print(y)  # [100, 200, 300] 

# 切片其实就是一个浅拷贝
names1 = ['张三', '李四', '王五', '杰克']
names2 = name1[::]
names1[0] = 'jerry'
print(name2)  # ['张三', '李四', '王五', '杰克']

• python 里的数据都是保存在内存里的

• python 里的数据又分为可变类型和不可变类型

  • 不可变类型：字符串、数字、元组

  • 可变类型：列表、字典、集合

• 不可变数据类型，如果修改值，内存地址会发生变化

• 可变数据类型，如果修改值，内存地址不会发生变化

• 使用内置函数id()，可以获取内存地址

python字典

• 列表可以存储任意数据类型，但是一般情况下，我们都存储单一数据类型

names = ['zhangsan', 'lisi', 'wangwu']
scores = [100, 98, 99, 97]

• 列表只能存储值，但是无法对值进行描述

1.字典的基本使用

• 列表不仅可以保存值，还能对值进行描述
• 使用大括号来表示一个字典，不仅有值value，还有值的描述key
• 字典里的数据都是以键值对key-value的形式保存的
• key和value之间使用冒号：来连接
• 多个键值对之间使用逗号，来分割

person = {'name': 'zhangsan',
         'age': 18,
         'math': 98,
         'Chinese': 95,
         'height': 180,
         'weight': 150
         }

2. 字典的注意事项

• 字典里的 key 不允许重复，如果 key 重复了，后一个key对应的值会覆盖前一个
• 字典里的 value 可以是任意数据类型，但是 key只能使用不可变数据类型，一般使用字符串

person = {'name': 'zhangsan',
         'age': 18,
         'math': 98,
         4: 'good',
          ('height','weight'): '180160'
         }  # 都是可以的，如果是list作为key，会报错

3. 字典的增删改查

• 查找数据
  • 字典的数据在保存时，是无序的，不能通过下标来获取，使用key来获取到对应的value
  • get方法：dict.get[key, default] ，传入key和默认值default，如果key不存在，返回传入的默认值

person = {'name': 'zhangsan', 'age': 18, 'math': 98}

print(person['name'])  # 'zhangsan'
print(person['height'])  # KeyError,如果key不存在，会报错

person.get('height')  # 使用get方法，如果key不存在，返回默认值None
person.get('gender', 'female')  # 如果key不存在，返回传入的默认值'female'
person.get('name', 'lisi')  # 'zhangsan'

• 新增数据
  • dict[key] = value：直接新增元素
  • dict1.update(dict2) ：将两个字典合并成一个字典

person1 = {'name': 'zhangsan', 'age': 18}
person2 = {'addr': '襄阳', 'height': 180}

# 字典之间不支持加法运算，字符串、元组、列表可以使用加法
person1.update(person2)
print(person1)  # {'name': 'zhangsan', 'age': 18, 'addr': '襄阳', 'height': 180}

• 修改数据
  • 直接使用key可以修改对应的value
  • 如果key存在，直接修改对应的value，如果key不存在，会在字典里添加一个新的key-value

person = {'name': 'zhangsan', 'age': 18}

person['name'] = 'lisi'
print(person)  # {'name': 'lisi', 'age': 18}

person['gender'] = 'female'
print(person)  # {'name': 'zhangsan', 'age': 18, 'gender': 'female'}

• 删除数据
  • dict.pop(key)：把key对应的键值对删除了，执行结果是被删除的value
  • dict.popitem()：删除一个元素，结果是被删除的这个元素组成的键值对
  • dict.clear()：清空字典
  • del dict[key]

person = {'name': 'zhangsan', 'age': 18, 'gender': 'female'}

x = person.pop('name')
print(x)  # 'zhangsan'
print(person)  # {'age': 18, 'gender': 'female'}

result = person.popitem()
print(result)  # ('gender', 'female')
print(person)  # {'name': 'zhangsan', 'age': 18}

4. 字典的遍历

• 字典遍历比较特殊，特殊在列表和元组是一个单一的数据，但是字典是键值对的形式

person = {'name': 'zhangsan', 'age': 18, 'gender': 'female'}

# 第一种遍历方式：直接for...in 循环字典
for x in person  # for...in 循环获取的是key
	print(x, '=', person[x])
    
# 第二种遍历方式：获取到所有的key，然后再遍历key，根据key获取value
for k in person.keys():
    print(k, '=', person[k])
    
# 第三种方式：获取到所有的value，一般不用
# 只能拿到值，不能拿key
for v in person.values():
    print(v)
    
# 第四种方式：
# for item in person.items():  # 列表里的元素是元组，把元组当做整体进行遍历
#    print(item[0], '=', item[1])

for k, v in person.items():
    print(k, '=', v)
'''
name = zhangsan
age = 18
gender = female
'''

5. 字典推导式

dict1 = {'a': 100, 'b': 200, 'c': 300}

dict2 = {v: k for k, v in dict1.items()}  # 字典推导式
print(dict2)  # {100: 'a', 200: 'b', 300: 'c'}

python集合

1.集合的基本使用

• 集合是一个不重复的，无序的，使用{} 或者 set 来表示的数据类型
• {} 有两种意思：字典、集合
• {} 里如果放的是键值对，它就是一个字典；如果 {} 放的是单个的值，就是一个集合
• 空集合的表示方式不是 {} , {} 表示的是空字典
• 空集合：set()

person = {'name': 'zhangsan', 'age': 18}  # 字典
x = {'hello', 1, 'good'}  # 集合

# 如果有重复的数据，会自动去除
names = {'zhangsan', 'list', 'wangwu', 'jack', 'tony', 'jack'}
print(names)  # {'zhangsan', 'tony', 'jack', 'list', 'wangwu'}

2. 集合的增删改查

• set.add(value) ：添加一个元素，如果已存在，不会添加
• set.pop()：删除一个元素，随机删除一个
• set.remove(value)：删除一个指定的元素，如果没有会报错
• set.clear()：清空一个集合
• set.union({value1, value2})：将多个集合合并并生成一个新的集合
• set.update({value1, value2})：括号里的集合拼接到set集合里

names = {'zhangsan', 'lisi', 'tony', 'jack'}

names.add('wangwu')  # {'list', 'wangwu', 'tony', 'jack', 'zhangsan'}
names.add('lisi')  # {'zhangsan', 'wangwu', 'tony', 'jack', 'lisi'}

# names.pop()  # {'wangwu', 'jack', 'tony', 'lisi'}
# names.remove('lisi')  # {'tony', 'zhangsan', 'jack', 'wangwu'}
# names.clear()  # set()

un_nm = names.union({'a', 'b'})  
print(un_nm)  # {'wangwu', 'zhangsan', 'jack', 'b', 'tony', 'a', 'lisi'}

names.update({'a', 'b'})  # {'a', 'zhangsan', 'tony', 'b', 'wangwu', 'lisi', 'jack'}

3.集合的运算符

• 集合支持很多运算符

first = {'李白', '白居易', '李清照', '杜甫', '王昌龄', '王维', '孟浩然', '王安石'}
second = {'李商隐', '杜甫', '李白', '白居易', '岑参', '王昌龄'}

# print(first + second)  # 不支持加法运算
print(first - second)  # {'孟浩然', '王维', '王安石', '李清照'}，减法，求差集
print(second - first)  # {'岑参', '李商隐'}
print(first & second)  # {'杜甫', '王昌龄', '白居易', '李白'},与运算，求交集
print(first | second)  # {'王昌龄', '李白', '杜甫', '李商隐', '王安石', '岑参', '李清照', '孟浩然', '王维', '白居易'},求并集

print(first ^ second)  # {'王维', '王安石', '李商隐', '孟浩然', '李清照', '岑参'}，异或，求两个所有不同的元素