python学习日记5 python基本语法（元组、字典和集合）

一、元组

1.概念

列表：是一种有序的，可变的，可以存储重复元素的，可以存储不同类型数据的集合
元组：是一种有序的，不可变的，可以存储重复元素的，可以存储不同类型数据的集合

元组和列表的不同之处：
a.数据类型的表示形式不同：列表:[] 元组：()
b.列表中的元素可以进行增加和删除操作，但是，元组中的元素不能修改【元素：一旦被初始化，将不能发生改变】

2.定义【重点】

元组：tuple 列表：list

注意：

​ 1、当元组中只有一个元素时，则需要在元素的后面添加逗号，以消除歧义

list2 = [45]
print(list2,type(list2))  # [45] <class 'list'>
tuple2 = (45,)			
print(tuple2,type(tuple2)) # (45,) <class 'tuple'>

​ 2、列表是可变的，元组是不可变的

list1[1] = 100
print(list1)
# tuple1[1] = 100   # TypeError: 'tuple' object does not support item assignment

​ 3、如果在元组里面嵌套了列表等可变数据类型的容器对列表修改元素是能进行修改的

t1 = (34,4,5,[45,5,78])
t1[-1][0] = 100
print(t1)  # (34, 4, 5, [100, 5, 78])

3.操作

# a. +
t1 = (1,2)
t2 = (3,4)
print(t1 + t2)  #（1，2，3，4）  但是不影响原元组

# b. *
print(t1 * 3)  # （1，2，1，2，1，2）

# c.in和not in
print(2 in t1)
print(23 not in t1)

# d.切片  同列表
t1 = (11,22,33,44,55,66,77,88,99)
print(t1[100:])   # ()
print(t1[0:-1])   # (11.....88)

print(t1[1:5:-1])  # ()
print(t1[-1:-5:-1]) # (99,88....66)

print(t1[-5:-1:-1])  # ()
print(t1[3::-1])     # (44...11)

# e.遍历   同列表
for ele in t1:
 print(ele)

for i in range(len(t1)):
 print(t1[i])

for i,num in enumerate(t1):
 print(i,num)

3.系统功能

# a.
print(len(t1))

# b
i = t1.index(22)

# c.
c = t1.count(22)

# d.
print(max(t1))
print(min(t1))

# e.list()和tuple()
l1 = [34,6]
print(l1,type(l1))  # [34, 6] <class 'list'>
t1 = tuple(l1)
print(t1,type(t1))  # (34, 6) <class 'tuple'>
l2 = list(t1)
print(l2,type(l2))  # [34, 6] <class 'list'>

二、字典

习惯使用场景【不是绝对的】：

• 列表更适合保存相似数据，比如多个商品、多个姓名、多个时间
• 字典更适合保存不同数据，比如一个商品的不同信息、一个人的不同信息 或者 需要定位数据

1.定义字典

​ 语法：{键1:值1, 键2:值2, 键3:值3, …, 键n:值n}

说明：

• 字典和列表类似，都可以用来存储多个数据
• 在列表中查找某个元素时，是根据下标进行的；字典中找某个元素时，是根据键查找的（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）
• 字典中的每个元素都由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值
• 键只能使用数字、布尔值、元组，字符串等不可变数据类型，但是一般习惯使用字符串，切记不能使用列表等可变数据类型,但是，值的数据类型没有限制
• 每个字典里的key都是唯一的，如果出现了多个相同的key,后面的value会覆盖之前的value

# 1.直接定义                *****
dict1 = {'name':'张三','age':18}
print(dict1)

# 2. 键值对赋值               *****
dict2 = {}
dict2['aaa'] = 10
dict2['bbb'] = 20
print(dict2)

# 3.dict(key1=value1,key2=value2.....)
dict3 = dict(x=23,y=56,z=10)
print(dict3)
# 注意：使用dict(key1=value1...)定义的字典，key只能是字符串 不能使用数字，元组
# dict32 = dict(10=0,20=1,30=2)

# 4.dict([(key1,value1),(key2,value2)......])
# 列表是可变的，元组是不可变的
dict4 = dict([('abc',100),('hello',200)])
print(dict4)

# 5.dict(zip([key1,key2.....],[value1,value2.....]))                 *******
dict5 = dict(zip(['zhangsan','jack','tom'],[12,20,15]))
print(dict5)

2.字典中键值访问

注意：
a.字典中的键相当于列表中的索引，列表中通过索引访问元素，字典中通过键访问对应的值
b.字典是可变的数据类型，可以通过键将原值获取出来，然后进行修改

# 1.通过键获取值
# a.语法一：字典[键]，注意：键一定要存在，才能获取到对应的值
info_dict = {'name':'jack','age':10,"gender":'male'}
age = info_dict['age']
print(age)
# 注意：如果访问一个不存在的key，则报错KeyError: 'hobby'

# b.语法二：字典.get(key,default),如果键存在，则获取对应的值；      ******
# 1>default省略，如果键不存在，默认获取到的None
print(info_dict.get('age'))
print(info_dict.get('hobby'))

# 2>【了解】default不省略，如果键不存在，获取到的default
print(info_dict.get('age',66))
print(info_dict.get('hobby','dance'))

# 2.通过键修改值
# 注意：字典是可变的数据类型，其中的值可以随时被修改，但是键不能被修改
info_dict = {'name':'jack','age':10,"gender":'male'}
print(info_dict)
# a.如果键存在，字典[键] = 值，表示修改指定键对应的值
info_dict['name'] = 'hello'
print(info_dict)
# b.如果键不存在，字典[键] = 值，表示将指定的键值对添加到字典中     ******
info_dict['score'] = 100
print(info_dict)

3.遍历字典

info_dict = {'name':'jack','age':10,"gender":'male'}

# 1.获取key               ******
for key in info_dict:
    print(key,info_dict[key])

# 2.获取key
# print(info_dict.keys())  # 获取字典中所有的键
for key in info_dict.keys():
    print(key,info_dict[key])

# 3.获取value
print(info_dict.values())   # 获取字典中所有的值
for value in info_dict.values():
    print(value)

"""
注意：
    a.通过key获取value,语法：字典[key]
    b.通过value获取key，无法直接获取，只能通过循环遍历
    c.在字典中，通过key获取到的value是唯一的，但是，通过value获取到的key不一定唯一
"""

# 4.获取key和value                 *******
# print(info_dict.items())     # 获取字典中的键值对
for key,value in info_dict.items():
    print(key,value)

5.字典系统功能

5.1 增

dict1 = {'a':10,'b':20}
print(dict1)

# 1.字典[key] = value,当key不存在时，表示增加键值对     *****
# dict1['c'] = 30
# print(dict1)

# 2.update():更新，合并字典，将指定字典中的键值对添加到原字典中     ******
# dict1.update(dict2):将dict2中的键值对添加到dict1中
new_dict = {'x':34,'y':75}
dict1.update(new_dict)
print(dict1)
print(new_dict)

# 3.setdefault(key,default):通过设置默认值的方式增加键值对，了解
dict1 = {'a':10,'b':20}
print(dict1)
# a.default省略,则向指定字典中添加：key:None
dict1.setdefault('abc')
print(dict1)  # {'a': 10, 'b': 20, 'abc': None}

# b.default未省略，则向指定字典中添加：key:default
dict1.setdefault('xyz',88)
print(dict1)  # {'a': 10, 'b': 20, 'abc': None, 'xyz': 88}

5.2 删

# 1.pop(key):弹出，删除指定key对应的键值对，     ********
# 【实际工作原理：将指定键值对从字典中移除，但是在内存中】
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
r = dict1.pop('age')   # pop跟列表中的用法类似，返回被删除的数据
print(dict1)
print(r)

# 2.popitem():在Python3.7之前，表示随机删除一对，在3.7之后，删除最后一对
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
dict1.popitem()
print(dict1)

# 3.clear()
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
dict1.clear()
print(dict1)

# 4.del xxx[xx]   删除字典中的某个键值对
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
del dict1['age']
print(dict1)

# del dict1     # 删除字典

5.3 改

# 其实就是增加键值对的另外一种用法   没有该key就是新增，有就是改
dict1 = {'name':"张三",'age':18,'hobby':"篮球"}
print(dict1)
dict1['age'] = 66
print(dict1)

5.2 查

print(len(dict1))  # 获取键值对的对数
print(dict1.keys())
print(dict1.values())
print(dict1.items())

6.列表推导式

​ 列表推导式：[元素的规律 for循环 if语句]
字典推导式：{key:value for循环 if语句}

# 已知一个字典{'a':10,'b':20},实现程序，交换key和value，生成一个新的字典
dict1 = {'a':10,'b':20}
# 方式一
dict2 = {}
for key,value in dict1.items():
    dict2[value] = key
print(dict2)

# 方式二
dict2 = dict(zip(dict1.values(),dict1.keys()))
print(dict2)

# 方式三
dict2 = {value:key for key,value in dict1.items()}
print(dict2)

三、集合

Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算

set与dict类似，但是与dict的区别在于只是一组key的集合，不存储value

本质：无序且无重复元素的集合

表示：{}，注意：如果直接使用{}则默认表示字典

1.列表，元组，字典，集合和字符串的区别

列表的本质：list,是一种有序的，可变的，可以存储重复元素的，可以存储不同类型的集合
元组的本质：tuple,是一种有序的，不可变的，可以存储重复元素的，可以存储不同类型的集合
字典的本质：dict,是一种有序的【Python3.7之后】，可变的，key不可以重复，
但是value可以重复，key只能是不可变的数据类型，value可以是任意的类型的集合
集合的本质：set,是一种无序的，可变的，不可以存储重复元素的，可以存储不同类型的集合
字符串的本质：str,是一种有序的，不可变的，可以存储重复字符的集合

2.集合的创建

{}直接表示空字典，而创建集合分为下面两种：

set1 = set()  # 空集合
set2 = {1，2，3}  # 非空集合

3.集合的运算

s1 = {1,2,3}
s2 = {3,4,5}
# 1、使用符号
# a.交集
print(s1 & s2)  # {3}
# b.并集
print(s1 | s2)  # {1, 2, 3, 4, 5}
# c.差集
print(s1 - s2)  # {1, 2}

# 2、系统功能
# a.交集
r1 = s1.intersection(s2)  # {3}
print(r1)
# b.并集
r1 = s1.union(s2)  # {1, 2, 3, 4, 5}
print(r1)
# c.差集
r1 = s1.difference(s2)
print(r1)   # {1, 2}

4.集合的系统功能

# 集合和字典之间的联系：集合相当于存储了字典中的key

# 一、增
# 1.add(x),x只能是不可变的数据类型，如果x是一个可迭代对象，则整体加入（列表、字典不能用）
s1 = {11,22,33}
print(s1)
s1.add(44)
print(s1)
s1.add("abc")
print(s1)
s1.add(True)
print(s1)
s1.add((55,66))
print(s1)

# 2.update(x)，x只能是可迭代对象，只会将可迭代对象中的元素加入【打碎加入】
# 可迭代对象：list,tuple,dict,set,set，range()等容器
s1 = {11,22,33}
# s1.update(44)  # TypeError: 'int' object is not iterable可迭代对象
s1.update("abc")
# s1.update(True)  # TypeError: 'bool' object is not iterable
s1.update((55,66))
s1.update([77,88])
s1.update({'x':10,'y':20})   # 注意：如果x是字典，只能添加key

# 二、删
# 1.remove(x):x表示需要删除的元素     ******
s1 = {11,22,33,4,78,79}
s1.remove(33)
print(s1)
# s1.remove(100)  # KeyError: 100

# 2.pop():因为集合是无序的，所以pop表示随机删除一个
s1 = {11,22,33,4,78,79}
s1.pop()

# 3.discard(x):和remove用法相同，如果被删除的元素不存在，remove会报错，但是discard不会报错  *****
s1 = {11,22,33,4,78,79}
print(s1)
s1.discard(33)
print(s1)
s1.discard(100)   # 不会报错

# 4.clear():清空
s1.clear()
print(s1)  # set()

# 三、查
s1 = {11,22,33,4,78,79}
s2 = s1.copy()

print(len(s1))
print(max(s1))
print(min(s1))