周记（python精简版）（二）

一 认识集合

集合(set)
    集合的特性:唯一性 无序性 主要用来进行去重和逻辑判断
        
表示形式为:
    用大括号{}包裹起来的数据 数据之间用逗号隔开
    
语法格式:
    集合名={数据1,数据2...}

food = {'旺仔牛奶', '螺蛳粉', '热干面', '可乐鸡翅', '蜜汁小汉堡', '东坡肉'}
print(food)

num = {1, 2, 5, 1, 2, 5, 4, 3, 1, 2}
# 正常输出一个集合里面重复的元素自动去除 代表集合唯一性去重性
print(num)
# print(num[3]) # 报错 因为集合是无序类型没有下标 所以序列类型的特性

 进行逻辑运算 集合逻辑运算
    集合1&集合2  -- 获取交集
    集合1|集合2  -- 获取并集
    集合1-集合2  -- 获取差集
    
符号输入
    & shift+7
    | shift+\
    - 直接减号
    
交集并集差集意义
    交集 -- 一个数据里两个集合都共有的
    并集 -- 两个集合里所有的数据(重复的数据只算一次)
    差集 -- 一个集合减掉另一个集合 剩下他独有的
    
例: 吃饭 两个碗
    a {青菜 鸡肉 胡萝卜}
    b {青菜 红烧肉 牛肉}
    
    交集:两个碗里共同都有的菜青菜
    并集:两个碗里的菜都加在一起(青菜，鸡肉，胡萝卜，红烧肉，牛肉)
    差集:碗之间相减 剩下独有的数据
        a-b= 鸡肉 胡萝卜
        b-a= 红烧肉 牛肉

class116 = {'秦锐灵', '荷包蛋', '谢斌'}
class117 = {'桑杰伦', '坤坤', '谢斌'}
# 交集
print(class116 & class117)
# 并集
print(class116 | class117)
# 差集
print(class116 - class117)
print(class117 - class116)

集合作用: 在有两个文件的时候 数据繁琐的时候 通过逻辑判断 可以帮助你找到重复的数据进行去重的操作 也可以通过交集操作去删除多余的文件 

集合可以放很多数据 字符串 布尔值 整型 浮点型 元组等等 但是集合不能放列表 
集合里面只能放不可修改的数据
集合里面不能放列表/集合/字典!!!

a = {'你好', 666, 6.6, True, (66, 7)}
print(a)
b = {[44, 55]}
print(b) #直接报错 因为列表是有序的强行转换会报错 虽然元组也是有序 但是元组是不可修改的保证数据的唯一

总结集合:

​ 存储非重复的数据 自动去重的效果

​ 进行逻辑判断 集合运算 交并差

​ 如果检测有重复的数据 集合就不会把重复数据放到存储空间里

 集合方法

增

add:增加一个数据(随机)
    语法格式:集合名.add(数据)

#增
a = {'你好', 666, 6.6, True, (66, 7, 66)}
a.add(8)  # 随机添加  因为无序
a.add('不良帅')
print(a)

删

pop:删除一个数据(根据版本不同有些从头开始删除或者随机删除或者从末尾删除)
    语法格式:集合名.pop()
        
remove:删除指定的数据
    语法格式:集合名.remove(数据)
        
clear:清空数据
    语法格式:集合名.clear()

#删
a = {'你好', 666, 6.6, True, (66, 7, 66)}
# a.pop() #随机一个个删除
# a.pop()
# a.remove(666)
# a.remove(6.6)
# a.remove(6.66)# 数据不存在会报错
# a.discard(6.66) # 数据不存在情况下 不会报错
a.clear()
print(a)

 二 字典 

字典(dict)
    表示形式为:字典是用大括号包裹起来的 存储数据是以键值对的方式存储 数据之间用逗号隔开 主要存储一些带有'说明'性质的数据
        
    语法格式:
        键值对:{键:值}
        字典名 = {键:值,键:值,键:值.....}
        字典的键是不可变类型 字典的值可以是任意类型

mes1 = {'姓名': '谭楚泽', '年龄': 18, '工资': 9.9, '姓名': '于健康'}
print(mes1)
# 字典中的键名重复的情况下 后面的会把前面的覆盖

name='谭楚泽'
name='于健康'
print(name)

字典的特性:
    1.通过键值对的方式存储数据 取数据 而不是通过下标索引
    2.字典里的数据是可以改变的 并且可以嵌套(字典里放字典)
    3.键名是唯一性
总结:用一个更好理解和清晰的方式来保存数据 保存方式为键值对 可以把键值对的理解为变量的概念
键名==变量名  值==变量值
 

字典方法

查

字典跟集合一样是无序序列所以无法通过下标进行获取数据或者查询数据

通过键(key)寻找值
语法格式: 字典名[键名]
        
get通过键(key)获取值
语法格式: 字典名.get(键名)
    
其他查询方法
字典名.keys() # 获取字典中所有的键
字典名.values() # 获取字典中所有的值
字典名.items() # 获取字典中所有的键值对(键值对是以元组的形式输出)

# 查
mes1 = {'姓名': '谭楚泽', '年龄': 18, '工资': 9.9}
print(mes1['姓名'])

print(mes1.get('姓名'))
print(mes1.get('年龄'))
print(mes1.get('工资'))
print(mes1.get('兴趣')) # 查询这个键不存在返回None

print(mes1.keys())
print(mes1.values())
print(mes1.items())

改

语法格式: 字典名[键名]=新的值

# 改
mes1 = {'姓名': '吉保拉達', '年龄': 99, '工资': 5000}
mes1['姓名'] = '小北' #修改原来的数据

#也可以理解为是一个增加方法
mes1['兴趣'] = '睡觉' #创建新的键值对
print(mes1)

增

语法格式: 字典名.setdefault(键,值)

    
可以增加也可以修改 一次性可以添加多个键值对 数据之间逗号隔开
语法格式: 字典名.update({键:值,键:值})

# 增
# food = {'红水果': '苹果', '蓝水果': '蓝莓'}
# food.setdefault('粉水果', '桃子')
# food.setdefault('紫水果', '葡萄')
# food.setdefault('紫水果', '茄子')  # 键名存在不会修改
# food.setdefault('五颜六色花里胡哨')  # 没有值 默认空NONE
# print(food)

ho = {'红头发': '黄滨', '绿头发': '坤坤'}
ho.update({'黄头发': '小北', '粉头发': '谭凯', '白色中分': '叶论文'})
ho.update({'黄头发': '小李'}) # 键名存在会修改 修改键的值 如果没有就会新增
ho.setdefault('五颜六色头发') # 没有值 默认空NONE
ho.update({'五颜六色头发':'小北'})
print(ho)

删

pop: 通过键名指定删除数据
    语法格式: 字典名.pop(键名)
    
popitem: 根据版本信息不同随机删除键值对
    语法格式: 字典名.popitem()
    
clear: 全部清除
    语法格式: 字典名.clear()

ho = {'红头发': '黄滨', '绿头发': '坤坤','黄头发': '小北', '粉头发': '谭凯','白色中分': '叶论文'}
ho.pop('黄头发') #通过键名删除
ho.pop('头发') #键名不存在是报错的
ho.popitem() #随机删除
# ho.clear() #全部清除
print(ho)

 

声明空变量

li=[] #声明空列表
lis=() #声明空元组
lst='' #声明一个空字符串
mo={} #声明一个空字典因为字典比集合用的多
me=set() #声明一个空集合

 

三 流程控制

Python中有三大结构: 顺序结构 分支结构 循环结构

分支结构:

    一次事件使用一组分支语句 -- 一组分支语句里面的if和else 只能有一个 elif可以多个.
    input得到的结果默认为str 不需要加str转换
    分支结构:
        单分支(if):满足条件就执行if里的代码
        双分支(if,else):满足条件就执行if里的代码,不满足就执行else里的代码
        多分支(if,elif,else):满足就执行if/elif里的代码,都不满足就执行else的代码
            

if 判断条件:
    执行语句 
elif 判断条件:
    执行语句
else:
    执行语句 

 循环结构:

    while循环:根据循环条件 如果循环条件为真就执行循环为假就结束循环
    for循环:在遍历/明确知道循环条件次数的情况下,用for更方便
        1.循环指定的次数 -- range()
        2.遍历数据 -- 有一堆数据,把里面的数据一个个取出来使用

语法格式:
    while 循环条件:
        执行语句 #当满足循环条件的时候执行 否则不执行
        循环条件更新

语法格式1:
    for 变量名 in 可迭代对象(字符串,列表,元组,字典,集合):
		执行语句
    #变量名一般命名是为i 也可以叫做其他 这里变量不需要提前声明 作为一个临时存储变量的地方
    #可迭代对象:可以暂时理解为存储多个数据的类型
    
语法格式2:
    for 变量名 in range(数值):
        执行语句
    range(起始值,终点值) #起点默认为0 终点前进一位

break和continue

用在流程控制里
break -- 结束
continue -- 跳过

# 罚你跑圈 100圈
# 1.李明天同学跑了10圈就不行了 选择不跑了 -- break结束循环
for i in range(1,101):
    print(f'跑了{i}圈')
    if i == 10: # 在我跑第十圈的时候就会结束执行
        print('跑不动不跑了')
        break

# 2.跑步跑不动 就抄书 但是比较精 有些页面不抄 -- continue 跳过
for i in range(1,101):
    if i == 10 or i == 20 or i == 50:
        continue
    print(f'这是我抄书的第{i}页面')

pass语句

pass是用作于分支结构语法中 相当于一个占位行为
当流程控制里面 语法没有想好的话 可以使用pass占位 防止一些不必要的报错

a = 1
if a == 1:
    print(6)
else:
    pass

 四 函数 

 定义函数

定义函数的语法格式:

1.def 函数名():
    代码
    
# 这里只是声明函数 并没有使用
# 调用函数
函数名()

# num()# 先定义在调用 程序是从上往下执行
def num():
    print(6666)


num()

2.设置空函数:
    def 函数名():
        pass # 当没有想好要设置什么内容的时候用pass占位不会报错

函数命名与变量命名规范一致

 函数参数

参数分为:

形参:没有具体的数据 -- 定义函数的时候出现

实参:有具体的数据 -- 调用函数的时候出现

导演 仙剑三 
男1号:张文祥
男2号:徐凤年
女1号:朱佳伟
女2号:未知
选好的角色就是实参  未知就是形参
 

语法格式:
	def 函数名(参数):
        代码
调用带参函数:
    函数名(参数)

 

1必备参数

有几个形参就要放几个实参 一个萝卜一个坑 否则就报错

语法格式:
    定义时:
        def 函数名(参数1,参数2):
            代码
    调用时:
        函数名(参数1,参数2)
 

# 1.必备参数
def woman(name, name1):
    print(f'{name},{name1}恭喜入选')


woman('小李','小王')
# 传递的参数多了少了都会报错

2默认参数

在声明形参参数的时候就提前传递好数据了 在后期进行调用的时候 就可以不传递实参 如果在调用函数的时候也进行了实参的传递的话 那么原有的数据就会被覆盖

语法格式:
    定义时:
        def 函数名(参数1,参数2=值): # 传递值 不是赋值
            代码
    调用时:
        函数名(参数1)       

# 2.默认参数
# def add(name, name1='潘俊余'):
#     print(f'今天课堂最帅的两个人{name},{name1}')
#
#
# add('李明天')
# add('李明天','高启强') # 高启强把原本的数据覆盖 这里多此一举
# 注意: 传递的默认参数要写在数据右边

3不定长参数1

长度不限 可一次性接收多个参数

当不确定要传几个值的时候就可以使用不定长参数

他可以接收多个参数值 也可以没有

该参数接收的多余的参数值后 会将值保存到元组中

不定长参数的表现形式为: * (后面的英文默认args 也可以是其他)
语法格式:
    定义时:
        def 函数名(*args):
            代码
    调用时:
        函数名(值1,值2.....)       

# 3. 不定长参数1
def info(name, age, *args):
    print('''
    ---- 个人信息 ----
    姓名:{}
    年龄:{}
    '''.format(name, age))
    print(args)
    print(args[0])


info('婷婷', 18, 25, 26, '何家辉')

4不定长参数2

长度不限 可一次性接收多个参数

但是接收的数据类型为键值对 得到的参数变量为字典类型的数据

他可以接收多个参数值 也可以没有

该参数将多余的参数值以字典的方式保存 其中参数名作为字典的键名

参数值作为字典的值

不定长参数的表现形式为: ** (后面的英文默认kwargs 也可以是其他)
语法格式:
    定义时:
        def 函数名(*kwargs):
            代码
    调用时:
        函数名(参数名=参数值,参数名1=参数值1....)   

# 4.不定长参数2
# def grade(C, M, E, **kwargs):
#     print(F'''
#     Chinese:{C}
#     Math:{M}
#     English:{E}
#     ''')
#     print(kwargs)
#
#
# grade(98, 99, 100, java=100, python=100)

def h(a, b, *args, **kwargs):
    print(a * b)
    print(args)
    print(kwargs)

# h(10,20,30,50,60,java=100,money=888)
# h(10,20,java=100,money=888)
# h(java=100,money=888)
# h(10,20,java=100,money=888,50,20)
# 不定长参数2一定是放在不定长参数1得后面

 5函数特性

1.函数能被引用(把定义好的函数赋值给变量)

数据名=函数名 # 把函数复制一份 给新的数据名
数据名=函数名() # 把函数返回值赋值给新的数据名

2.函数可以作为元素放在列表,元组,字典,集合中使用 

3.函数可以作为参数 传递给另一个函数

4.函数可以作为返回值

五 文档字符串

与之前学的注释不同

他是写在函数里的注释但是可以被输出出来

写函数时候使用文档字符串更好

作用:
    1.表达函数的作用
    2.表达函数参数的作用
    3.表达函数返回值的作用
# 三对引号(单/双)
语法格式:
	def 函数名():
        '''文档字符串内容'''
        代码

输出方式:
    函数名.__doc__
    print(函数名.__doc__)

def ll():
    '''我是不会被输出的
    注释内容 你就看看我就行了'''
    pass

print(ll.__doc__)

def ll():
    '''我是不会被输出的
    注释内容 你就看看我就行了'''
    print(666)
ll()
print(ll.__doc__) # 输出函数里的注释内容
#
# print(print.__doc__)
# print(len.__doc__)

 

六 名称空间

名称空间: 就是存放名字的地方 即存放变量名 函数名

名称空间 -- 存储变量名 函数名 模块名

内存数据 -- 变量值 函数代码 模块代码

一共有三层结构

1.内建名称空间(存放内置函数)
	生命周期: 随着Python程序启动而生成,在程序关闭时收回 清除所有数据
    加载顺序: 最先被加载出来的
    存放对象: 内置函数 print input type len max min 

2.全局名称空间(Python定义在外层的名字)
	生命周期: 随着Python文件执行之前产生 运行完后销毁
    加载顺序: 第二个被加载出来的
    存放对象: 在Python外层写的代码 定义的变量名 函数名
        
3.局部名称空间(存在函数内定义的名字)
	生命周期: 随着函数调用而产生 在结束调用时销毁
    加载顺序: 在调用时才会被加载
    存放对象: 在函数里定义的变量名 函数名 形参参数

# a = 666  # 全局
#
#
# def fun():
#     z = 777  # 局部
#     print(888)
#
#
# fun()
# print(print)

# 加载顺序: 内建>全局>局部
# 查询顺序: 局部>全局>内建
# 都没有找到就会抛出nameerror

# def fun():
#     a = 111
#     print(a)
#
# fun() # 不归大程序管
# print(a) # 全部都搜索不到变量


# # input='婷婷'
# def fun():
#     input='叶论文'
#     print(input) #先从局部找 找不到 就去全局找  就去内建
#
#
# print(input)
# # 三个名称空间都是独立性的


'''
曹操
内建名称空间: 曹操的兄弟 一开始打天下就跟着的 --> 曹仁 夏侯惇 夏侯渊
全局名称空间: 曹操打天下过程中收复的文臣武将 --> 典韦 张辽
局部名称空间: 曹操分封的太守(市长)自己的小弟 --> 太守的小弟会听太守的话 但不一定听曹操的

手机出厂自带就是 内建
你额外下载的软件就是 全局
软件里还带的小程序 局部
'''

 

七 作用域

作用域: 一个数据能够使用的范围

作用域分为: 全局作用域 局部作用域

全局作用域: 内建名称空间 全局名称空间
    内置函数 外层定义的变量 函数名
    公共WiFi 所有人都可以使用


局部作用域: 局部名称空间
    函数内部的变量和函数名
    独有wifi 只能我自己用

c = 30 # 公共WiFi 随便用


def fun():
    a = 10
    print(a)


fun()
print(a) # 这是私有WiFi 你用不了

1 global 提权

我想要把私有WiFi变共有WiFi 就给他个权利 提权
提权: 让一个数据从局部变为全局
    global=大方的人
    语法格式:
    def 函数名():
        global 变量名
        操作变量
    函数名()
    print(变量)

# 提权
def name():
    global a
    a = '婷婷'


name() # 局部名称空间的创建 需要调用函数才可以生成对应的名称空间
print(a) # 把局部数据变为全局了

 2 nonlocal 降权

我是小气的人我把大家用的WiFi 私有化了 降权
降权: 将局部变量再深度局部化
    
    nonlocal=小气鬼

# 降权
def fun1():
    a = 1 # 这个a 在函数里算是公共的(全局)

    def fun2():
        nonlocal a # 把变量a霸道的抢过来 私有化
        a = 0

    fun2()
    print(a)


fun1()

 

八 匿名函数

平时使用的函数==有名函数

匿名函数顾名思义=无名函数

匿名函数作用: 不想取名 并且函数只用一次的时候使用

语法格式:
    lambda 变量:操作

def fun(a, b):
    return a + b


print(lambda a, b: a + b)  # 匿名函数的内存地址
print((lambda a, b: a + b)(1, 2))  # 声明匿名函数 并且调用函数传参


def talk1():
    print('一起来玩吧')


print((lambda a: print(a))('一起来玩吧')) # 声明匿名函数 并且调用函数传参 返回他的print返回值
talk2 = lambda a: print(a)
talk2('一起来玩吧')