Python基础学习三（字典、集合、类型转换、深浅拷贝、函数基础、函数进阶）

喜欢下雨的猫

已于 2022-03-05 17:40:22 修改

阅读量628

点赞数

分类专栏： python学习文章标签： python 开发语言后端

于 2022-01-01 10:29:27 首次发布

本文链接：https://blog.csdn.net/weixin_45377154/article/details/121804820

版权

python学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一、字典

1、字典的定义

字典是一系列的键-值对，键和值之间使用冒号隔开，而键-值对之间使用逗号隔开

2、字典的格式

字典格式：
字典名 = {“key”:values1,“key1”:values2,“key3”:values3,……}
注意：字典里面的数据以键-值对形式存在，键具有唯一性，值可以重复

3、字典的常见操作

"""
3.1 查找元素 ：字典序列[key]
3.2 增加元素 ：字典序列[新key] = 新值
3.3 删除元素 ： del 字典序列[指定key值]
3.4 清空字典： 字典.clear()
"""
#3.1 查找元素
age = {"age1":18,"age2":19,"age3":20}
age["age1"]
print(age["age1"]) #输出结果为：18

#3.2 增加元素
age["age4"] = 21
print(age) #输出结果为：{'age1': 18, 'age2': 19, 'age3': 20, 'age4': 21}

#3.3 删除元素
del age["age4"]
print(age) #输出结果为：{'age1': 18, 'age2': 19, 'age3': 20}

#3.4清空字典
age.clear()
print(age) #输出结果为{}

"""
3.5 len(目标)： 返回字典中键值对的个数
3.6 keys() ：   字典名.keys(),返回字典中的所有键
3.7 values() ：  字典名.values()，返回字典中的所有值
3.8 items()  :   字典名.items() 能够将键值对输出，同时存放在字典里面的序列中
3.9 get() : 字典名.get(key值) 值不存在返回一个none 返回字典中的值
"""
age = {"age1":18,"age2":19,"age3":20}
#3.5 len()
len(age)
print(len(age)) #输出结果为3

#3.6 keys()
age.keys()
print(age.keys()) #输出结果为：dict_keys(['age1', 'age2', 'age3'])

#3.7 values()
age.values()
print(age.values()) #输出的结果为：dict_values([18, 19, 20])

#3.8 items()
age.items()
print(items()) #输出结果为：dict_items([('age1', 18), ('age2', 19), ('age3', 20)])

#3.9 get()
age.get("age1")
print(age.get("age1")) #输出结果为：18

"""
3.10 遍历字典中的key：for key in 字典名.keys()
3.11 遍历字典中的value： for value in 字典名.vlues()
3.12 遍历字典中的元素items： for items
3.13 遍历字典中的键值对key,value: for key,value in 字典名.items()
"""
age = {"age1":18,"age2":19,"age3":20}
# 3.10 遍历字典中的key
for key in age.keys():
	print(key) #输出结果为：age1 age2 age3

# 3.11 遍历字典中的value
for value in age.values():
	print(value) #输出结果为：18 19 20

# 3.12 遍历字典中的元素item：
for item in age.items():
	print(item) # 输出的结果为：('age1', 18)  ('age2', 19)  ('age3', 20)
# 3.13 遍历字典中的键值对key,value:
for key,value in age.items():
	print(key,value) #输出的结果为: age1 18   age2 19  age3 20

二、集合

1.集合的定义

集合是由不同元素组成的一组无序序列，可作为字典的key，它有一个目的是将不同的值存放在一起，不同的集合间用来做关系运算，无须纠结于集合中的单个值

2.集合的定义格式

集合名 = set() (空集合)
有数据的集合：
set = {element1,element2,element3}
其中set是集合名称，element1、element2、 element3都是集合中的元素，个数没有限制。

3、集合的常见操作

"""
3.1 add()语法：集合名.add(元素) 给集合添加元素
3.2 update()语法：集合名.update(元素) 添加单个字符串会将字符串拆分添加，修改集合的元素、添加新的集合到当前集合中
3.3 remove()语法： 集合名.remove(元素) 删除集合中的元素
3.4 pop()语法： 集合名.pop() 随机删除集合中的元素
3.5 判断数据是否存在于集合中 数据 in集合
3.6 判断数据是否不存在于集合中 数据 not in 集合
"""
age = {1,2,3,4,5}
3.1# add()
age.add(6)
print(age) #输出结果为：{1, 2, 3, 4, 5, 6}

3.2 update()
age.update("hahah") #会将添加的元素拆分
print(age) #输出的结果是：{1, 2, 3, 4, 5, 'h', 'a'}

3.3 remove()
age.remove("h")
print(age) # 输出结果为：{1, 2, 3, 4, 5, 'a'}

3.4 pop() #进行无序排列，然后将左边第一个元素删除
age.pop()
print(age.pop()) #输出结果为：{2, 3, 4, 5, 'a'}

3.5 判断数据是否存在于集合中
3 in age
print(3 in age) # 输出结果为True

3.6判断数据是否不存在于集合中
3 not in age 
print(3 not in age) # 输出结果为False

"""
max() :返回容器中元素的最大值
min() :返回容器中元素的最大值
enumerate() 函数用于将一个可遍历的数据对象组合为一个索引序列 enumerate
"""
age = {1,2,3,9,4,5,6}
print(max(age)) # 输出结果为9
print(min(age)) # 输出结果为1

for i in enumerate(age):
	print(i)
#输出结果为：(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
(5, 6)
(6, 9)

4、交集与并集

"""
交集，就是两个集合相交的部分，运算符为“&”；

并集，就是合并在一起的集合，运算符为“|”；

设A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做集合A与集合B的差集。在Python中，进行差集运算时使用“-”符号。

最后还有一个对称差集，运算符为“^”。
对称差集也称为对称差分或者补集，设A，B是两个集合，所有不相同的集合，叫做集合A与集合B的对称差集（对称差分或者补集）。在Python中，进行对称差集运算时使用“^”符号。

"""
s1 = {1,2,3,4,5}
s2 = {1,2,6,7,8}

#交集
c = s1&s2
print(c) #输出结果为：{1, 2}

# 并集 去除重复的部分
c = s1|s2
print(c)  #输出结果为：{1, 2, 3, 4, 5, 6, 7, 8}

# 差集 两个集合之差

c = s2 - s1
print(c)  #输出结果为：{8, 6, 7}

#对称差集
c = s2^s1
print(c) #输出结果为：{3, 4, 5, 6, 7, 8}

三、类型转换和列表推导式

3.1 类型转换

"""
不可变数据类型：不可变数据类型[包括:整型(int)，浮点型(float)]，字符串(str)，元组(tuple)，(数据更改前后，内存id发生改变)
可变数据类型：可变数据类型[包括:列表(list)，字典(dict)，集合(set)。(数据更改前后，内存id不变)
数据类型的转换：
tuple()	将某个序列转换成元组
list()	将某个序列转换成列表
set()	将某个序列转换成集合
id()语法，id(目标)，作用：获取对象的内存地址，是一个内置函数
"""
# 不可变数据类型 int,float,str,tuple
i= 2
print(id(i))
#①输出结果为：140714986209584
i = 3
print(id(i))
#②输出结果为：140714986209616
#①②两者的id不一样

# 可变数据类型 list set dict
list = [1,2,3]
print(id(list))
#③输出结果为：2326727840264
list.append(4)
print(id(list))
#④输出结果为：2326727840264
#③，④的id是一样的

3.2 列表推导式

"""
列表推导式语法格式：
[表达式 for 临时变量 in 列表  ]
[表达式 for 临时变量 in 列表 if 条件表达式 ]
[if 条件表达式] 不是必须的，可以使用，也可以省略，in后面还可以写range()、可迭代对象。

"""
# 将0-10 添加到一个列表中
list = [i for i in range(11)]
print(list)
#输出结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 将0-10 中的偶数添加到列表中
list1 = [i for i in range(11) if i%2==0]
print(list1)
#输出结果：[0, 2, 4, 6, 8, 10]

四、深浅拷贝

"""
1、直接赋值：其实就是对象的引用（别名）。
2、浅拷贝：拷贝父对象，不会拷贝对象的内部的子对象。
    浅拷贝语法：
        copy.copy(拷贝对象) 或者 拷贝对象.copy()
3、深拷贝：copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。

4、导入一个模块，这里使用copy就需要导入copy()
import copy() 导入模块的方法
"""
# 1、浅拷贝
#导入copy模块
import copy

list1 = [1,2,3,[4,5,6]]
list2 = copy.copy(list1)
print(list2)
# 输出结果为：[1, 2, 3, [4, 5, 6]]
print(id(list1[3]))
print(id(list2[3]))
#输出结果为：1370734184008
#输出结果为：1370734184008
#浅拷贝：拷贝父对象，不会拷贝对象的内部的子对象。且两个的内部子对象都指向同一个id，


# 2、深拷贝

list3 = [1,2,3,[4,5,6]]
list4 = copy.deepcopy(list3)
print(list4)
#输出结果为：[1, 2, 3, [4, 5, 6]]
print(id(list3[3]))
#输出结果为：2455899195912
print(id(list4[3]))
#输出结果为：2455899194184
 #深度拷贝,list4完全拷贝了父对象list3及其子对象list3[3]，两者是完全独立的。所以两者子对象的id不同

五、函数基础

函数是一个被命名的，组织好的，可重复使用的，用来实现单一或者相关联功能的代码段。简单的来说函数就是一段封装起来的代码 , 可以随时调用。

1、函数的定义格式及调用

"""
1、函数的定义
def 函数名():
	语句1 函数体
	……
	语句n
2、函数的调用
函数名()
"""
def fun():
	print("好好学习")
	print("天天向上")
fun()

2、函数的形参和实参及四大参数

2.1形参和实参

"""
	在函数中可以看做是一个占位符，没有数据，只能等到被调用时接收传递进来的数据。是在定义函数的函数名后括号内使用的参数。
	在调用函数时，实实在在的数据，会被函数内部代码调用，被称为实参。是在调用函数的函数名后括号内使用的参数。
"""
def fun(a):#这里的a是形参
	print("好好学习")
	print("天天向上")
	print(a)
fun(3)#这里的3是实参```

2.2 必备参数

def funb(a,b)
#写了几个参数传参就要传几个,上面表示要传两个参数

2.3 默认参数

def funa(a=12):
	print(a)
fun(11)
#给某个参数指定一个默认值，这里表示a的默认值为12

2.4 可变参数

def  func(*args):
	print(args)
func("好好学习","天天向上")
#将实参所有的位置参数接收，放置在一个元组中

2.5 关键字参数

def funa(**kwargs):
	print(kwargs)
funa(title="好好学习")
#接受所有的关键字参数然后将其转换成一个字典赋值给kwargs这个形参,
#注意：在使用关键字参数的时候我们传递的#值类似于变量的形式

3、返回值

"""
def 函数名():
	语句体1 （函数体）
	……
	return（数值或者参数）
（return）语句就是将结果返回到调用的地方，并把程序的控制权一起返回，函数可以有返回值也可以没有,没有返回值输出none。
"""
def fun():
	print("好好学习")
	print("天天向上")
	return "努力挣钱","财富自由"
	print("好好生活")
	return "哈哈哈哈"
print(fun())

#注意：
# 1、返回值后面无论有多少内容都不会再执行
# 2、return 后面什么都不写就会返回一个None
# 3、return 后面只有一个值则原样返回，如果有多个值则以一个元组的数据类型返回
# 4、一个函数当中可以出现多个return ，但是只有一个会执行

4、函数嵌套

"""
def 外部函数名()
	语句n
	def 内部函数名():
		语句n
def 是关键字，定义一个外部函数时在函数的内部再定义一个函数，也就是内部函数，
"""
def fun1():
	print("好好学习")
	print("天天向上")
	def fun2():
		print("努力挣钱")
		print("好好生活")
	fun2()
fun1()
# 1、内部函数必须调用才能执行，内部函数的调用放在内部函数内部函数的里面
# 2、内部函数的调用前提是外部函数调用，再看内部函数是否能够调用

六、函数进阶

1、作用域——局部变量，全局变量（global，nonlocal关键字）

局部变量：局部变量的作用域是定义该变量的函数或定义该变量的语句。就是说，局部变量只在定义它的函数或语句范围内有效，只能在这个作用域使用。
全局变量：全局变量也称外部变量，它是在函数外部定义的变量。它不属于哪一个函数。就是说，定义的函数都可以使用全局变量。

"""
——局部变量和全局变量的使用
"""
a = 1
def fun():
    a = 3
    print(a)# 这里的a是调用的是 a = 3当函数内部有变量时，就会从函数内部进行寻找，有的话就直接使用，没有的话就到函数外面去寻找。就近原则
fun()
print(a) #这里的a是调用的a=1
# 注意：在函数中定义的参数只能在内部调用

"""
——global，nonlocal关键字
gloabal 全局变量 格式 global 变量名
nonlocal 将变量声明为外层变量
"""
#global关键字使用
def fun1():
    global a
    a = 3
    print(f"我有{a}个好朋友")
def fun2():
    print(f"我有{a}个好朋友2")
fun1() #输出结果：我有3个好朋友
fun2() #输出结果：我有3个好朋友2
print(a) # 输出结果：3

# nonlocal关键字使用

def fun1():
    a = 3
    print(f"我有{a}个好朋友")
    def fun2():
        nonlocal a
        a = 4
        print(f"我有{a}个好朋友2")
    fun2() #输出结果：我有4个好朋友2
    print(f"我有{a}个好朋友2") #输出结果：我有4个好朋友2

fun1() #输出结果：我有3个好朋友

2、匿名函数

匿名函数：通过lambda关键字来定义的函数称为匿名函数，匿名函数的格式：函数名 = lambda 参数：表达式，先写lambda关键字，然后依次写匿名函数的参数，多个参数中间用逗号连接，然后是一个冒号，冒号后面写返回的表达式。

"""
匿名函数：lambda关键字
定义格式：
函数名 = lambda 参数：表达式 表达式就是return后面的结果
"""
A = lambda a = 1 , b = 2: a + b
print(A()) #输出结果：3


A = lambda a,b : a if a>b else b
print(A(3,4)) #输出结果：4

3、内置函数

内置函数：嵌入到主调函数中的函数称为内置函数，又称内嵌函数。作用是提高程序的执行效率，编程语言中预先定义的函数。内置函数的存在极大的提升了程序员的效率和程序的阅读。

"""
内置函数：嵌入到主调函数中的函数称为内置函数，又称内嵌函数。 作用是提高程序的执行效率，编程语言中预先定义的函数。内置函数的存在极大的提升了程序员的效率和程序的阅读。
1、print() 屏幕输出
2、list()  将一个可迭代对象转换为列表
3、abs() 返回绝对值
4、创建一个无序不重复元素集
5、tuple() 将一个可迭代对象转化为元组
6、sum() 求和
7、zip() 将可迭代对象作为参数，将对象中对应的元素打包成一个个元组
8、map() 可以对可迭代对象中的每一个元素进行映射，分别取执行
"""
# 返回绝对值 abs() 
a = -1
print(abs(a)) # 输出结果1

# 求和 sum()
a = [1,2,3]
print(sum(a)) #输出结果为：6 注意sum里面的参数是可迭代的，不然会报错

# 取最小值 min()
a = [1,2,3]
print(min(a)) #输出结果为：1

# 将可迭代对象作为参数，将对象中对应的元素打包成一个个元组 zip()
a = [1,2,3]
b = [4,5,6]
print(list(zip(a,b))) #输出结果为：[(1, 4), (2, 5), (3, 6)]

# tuple 将可迭代对象作为参数，将对象中对应的元素打包成一个个元组
a = [1,2,3]
print(tuple(a)) #输出结果为：(1,2,3)

# 可以对可迭代对象中的每一个元素进行映射，分别取执行 map()
a = [2,3,4]
def A(x):
    return x*2
c = map(A,a)
print(list(c)) #输出结果为: [4, 6, 8]

4、拆包

拆包：对于函数中的多个返回数据, 去掉元组, 列表或者字典直接获取里面数据的过程。

"""
拆包：对于函数中的多个返回数据, 去掉元组, 列表 或者字典 直接获取里面数据的过程。
"""
lia = [1,2,3,4,5,6]
# a,*b = lia
a,*b,c,d,e,f = lia
print(a,b,c,d,e,f)# 输出结果为：1 [2] 3 4 5 6   注意，被表上*号的会称为列表list数据