【python】零基础从入门到精通(四）

day8-散列类型与字符编码

初识散列类型(无序序列)

数据类型分为3种
	前面已经学过了两种类型:
   	1.数值类型:int/bool/float 只能存储单个数据
    
    2.序列类型:list/tuple/str,有序的存储多个数据--有序类型,有下标,可以进行切片索引步长的操作
        
    3.散列类型:
        1.可以存放多个数据
        2.内部是无序的(没有下标)
        3.内部数据不重复
       	集合跟字典都是散列类型
1
2
3
4
5
6
7
8
9
10
11

一、认识集合

集合(set)
	表示形式为:用大括号{}包裹起来的数据,里面的数据用逗号隔开
   	集合的特性:
        1.唯一性
        2.无序性 主要是用来进行去重和逻辑判断
        
语法:
    集合名={数据1,数据2,数据3,....}
案例:
    room={'许叶彤','李震','尹天浩','帅过过','吊炸天'}
    print(type(room))
    print(room)
    
    num={1,5,6,7,8,9,1,5,6,2}
    print(num) #正常输出一个集合,里面的重复元素会自动去除,代表集合的唯一性
    #print(num[2]) #报错,因为集合是无序类型 没有下标
    
集合可以进行简单的逻辑运算,交并差集
	集合1 & 集合2-->获取交集--一个数据,两个集合里都有它
    集合1 | 集合2-->获取并集--两个集合里的所有数据(去重)
    集合1 - 集合2-->获取差集--两个集合之间,自己独有的数据
    
符号输入
	& --> shift + 7
	|  --> shift + \
	- --> 减号
    
生活例子:现在我们有两个碗
    碗A{花菜,鸡肉,凤爪}
    碗B{鸡肉,豆腐,梅菜}
交集-->两个碗里都有的菜-->鸡肉
并集-->两个碗里所有的菜-->花菜,鸡肉,凤爪,豆腐,梅菜
差集-->碗A-碗B-->碗A独有的数据-->花菜,凤爪
	碗B-碗A-->碗A独有的数据-->豆腐,梅菜
    
num1={1,2,3}
num2={3,4,5}
print(num1&num2) #交集{3}
print(num1|num2) #并集{1, 2, 3, 4, 5}
print(num1-num2) #差集{1, 2}
print(num2-num1) #差集{4, 5}

集合里可以放很多数据(不能放列表)
集合里只能放不可变的数据
talk={'你好',66,9.9,True,(1,2,3),[1,2]}
print(talk) #集合里不能放列表,会报错

集合的本质:
    1.存储非重复数据-->自动去重
    2.进行逻辑判断,进行交并差运算
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

集合的方法

room= {‘麻子’,‘高启盛’,‘老莫’,‘高启强’}

增

add: 添加一个数据到集合里
    集合.add(数据)
    room.add('好好学习') #随机,因为无序所以随机增加

update:  把一个序列类型打散后添加到集合里
    集合.update(序列数据)
    room.update('别做坏事')
1
2
3
4
5
6
7

删

pop: 删除一个数据(随机删除)
    集合.pop()
    room.pop()
    
remove: 删除指定的数据
    集合.remove(数据)
    room.remove('高启强')
    
clear:清除所有数据  
    集合.clear()
    room.clear() #set()
1
2
3
4
5
6
7
8
9
10
11

二、认识字典

字典(dict)
	表示形式为:字典是用大括号包裹起来的数据,存储数据是以键值对的方式来存储,数据之间也要用逗号隔开,主要存储一些带有'说明'性质的数据
        键值对   左边是键  中间冒号  右边是值
        key:value-->相当于键是名字,值就是数据
            
键名一般是用字符串或整型来表示
值里面什么都可以放,放变量,函数,杂七杂八的都OK

声明语法:
    字典名={键:值,键:值}
    
info={'姓名':'陌上','余额':8.8,'年龄':18}

info1={
    '姓名':'陌上',
    '余额':8.8,
    '年龄':18
}

字典的输出:
    print(字典名)
    print(info)
	print(type(info))
    
    print(字典名[键名]) #输出指定键的值
    print(info['姓名']) #陌上

#姓名=伊诺,年龄=18,余额=8.8
这里的字典的作用是一个说明效果,方便理解,有一个较好的可读性

用字典类型保存的数据有一点好处:
    比起用列表/元组存储数据,他看起来更加清晰
    info={'陌上',8.8,18} #这里的一些数据如果不加注释说明,可能不清楚表示什么东西
所以如果要的数据,有明显的对照关系,就可以用字典来保存,看起来更加的清晰明了

字典的特性:
    1.字典是通过键值对的方式来获取数据,而不是通过下标索引获取
    2.字典里的键是不可变的,只能使用数字,字符串,或者元组,不能使用列表
    day=(2,3)
    food={
        1:'肉',
        '水果':'葡萄',
        day:'打折'
    }
    print(food)

    info2={
        [1,2]:'陌上'
    } #报错
    #print(info2) #报错,字典里的键是不可变的,只能使用数字,字符串,或者元组,不能使用列表
    3.字典里的键值是可以修改的,还可以嵌套(字典里面还可以放字典)
    info3={
    '姓名':'陌上',
    '余额':[8.8,9.9,10],
    '地址':{1:'工作地址',2:'家乡地址'}
}
	print(info3)
    
    4.字典里键名是唯一的
    info4={
    '姓名':'伊诺',
    '余额':8.8,
    '年龄':18,
    '年龄':19,
    '年龄':20
    } #只会保留最后一个年龄的键值对
    print(info4) 

总结:用一个看起来更清晰的方式来保存数据,保存方式为键值对
    可以把键值对理解为变量 键就是变量名  值就是变量值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

字典方法

info={
    '姓名':'陌上',
    '余额':8.8,
    '年龄':18
}
1
2
3
4
5

增

setdefault: 给字典添加一个键值对. 如果已经有这个键了.就不会新增
    [1.新增一个键,没有写值,值默认为空]
    字典.setdefault(键名)
    info.setdefault('身高') #没有值,值默认为空
    
    [2.新增一个键值对]
    字典.setdefault(键名,值)
    info.setdefault('家乡','陕西宝鸡')
1
2
3
4
5
6
7
8

删

pop: 通过键名删除指定的数据
    字典.pop(键名)
    info.pop('年龄')
    
popitem:  删除一个键值对,从最后一个数据开始删  
    字典.popitem()
    info.popitem()
    
clear: 清除整个字典    
    字典.clear()
    info.clear()
1
2
3
4
5
6
7
8
9
10
11

改

update: 以键值对的方式修改数据.如果没有就新增
    [1.修改数据]
    字典.update({键:想修改的值})
    info.update({'姓名':'陌上帅哥'})
    
    [2.如果没有这个键值对,就转为新增]
    字典.update({键:值})
    info.update({'毕业学校':'西安邮电大学'})
    
    [3.增加多个键值对]
    字典.update({键:值,键:值})
    info.update({'职业':'学生','性别':'女'})
    
字典[键名]=值 #修改指定键的值,键是存在的情况下会讲原来的值进行修改,否则添加为新的键值对
info['性别']='男' #找到info里面的性别 把值改为男
info['生肖']='猴' # 也算是一个新增方法,创建新的键值对
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

查

字典跟集合一样是无序序列,所以是无法通过下标进行获取数据,但是字典有查询数据的方法,但是查询的方法依旧也是用print来输出

get: 通过键名,获取值. 如果没有这个键,输出None
    字典.get(键名)
    print(info.get('余额'))
    print(info.get('籍贯')) #没有籍贯这个键,就输出None
    
keys: 获取所有的键
    字典.keys()
    print(info.keys())
    
values: 获取所有的值    
    字典.values()
    print(info.values())
    
items: 获取所有的键值对
    字典.items()
    print(info.items())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

声明空变量

列表名=[] #声明一个空列表
元组名=() #声明一个空元组
字符串名='' #声明一个空字符串
集合名=set() #声明一个空集合
字典名={} #声明一个空字典
1
2
3
4
5

三、字符编码

如果你要出国玩,翻译工具-->把你想说的话,通过翻译工具的方式,传达给别人

计算机语言最底层是由0和1组成,计算机是怎么做到吧一堆的0和1变成我们看到的字,--->字符编码-->在计算机里面有一个翻译工具,作用就是把机器码数据转换成人类看的懂的字

字符编码--翻译工具--把计算机的东西翻译成人类能理解的东西

第一套字符编码叫ASCII码,里面收纳了一些常用符号,数字,字母-->没有中文或者其他语言
asciima表用法就有点类似于字典-->每个字在表里都有对应的一个序号,可以通过序号找到字,也可以通过字找到序号
但是随着科技进步发展,很多国家都有了自己的计算机技术能力,这时候这个ascii码表就不能满足需求了,-->我要用中文.日文

后面很多国家,地区都研发了一套自己的字符编码:
    中国研发GBK编码-->有两万多个汉字
    同时间中国台湾-->big5码,大五码,繁体字
    
每个国家的语言 不同 所以只显示自己国家的文字
用别的国家软件就容易出现问题
#就比如说用GBK写的内容用big5码打开就可能是乱码不通用

针对这个问题,有个国际组织,专门收集了全世界大部分的国家的语言文字,汇总做了一个大字典并推行使用,以后统一用大字典就可以尽量避免乱码问题-->utf-8

核心点:
    1.目前世界上最主流的编码是utf-8,#大部分默认就用utf-8
    2.一个程序是用什么编码写的,就用什么编码去打开
    
在程序中每个字都是有对应的序号
ord(字符) -->通过字符,找到序号
chr(序号) -->通过序号,找到字符

	print(ord('A'))
    print(ord('B'))
    print(chr(65))
    print('A'>'B') #实际比较的是ascii表的序号
    
凯撒密码 凯撒加密
计算机自动关机的指令 先按win+r 或者打开cmd 
指令:shutdown -s -t 秒数
    
shutdown -a  取消关机


import os # 准备一个作案工具.这个工具可以让你运行cmd指令
code = "rgtscnvm,r,s2222" # 被加密过后的数据 #shutdown -s -t 秒数
run = "" # 空的字符串
for i in code: # 写了一个循环,把这个字符串里的所有元素都取了出来
    run+= chr(ord(i)+1) # 把每个元素都+1,并添加到run里面
os.system(run)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

day9-函数基础与函数参数

一、初识函数(function)

编程函数!=数学函数,里面的是逻辑,功能,而不是套公式

编程函数的作用是实现特定操作的一段代码

生活例子
我现在请客,每个人,我都点了一份一样的吃的
	1.上校鸡块
    2.可乐
    3.薯条
100个同学 都点这样的 炸鸡店的老板我需要
这个点餐比较麻烦,我要重复说一百次
这个时候会用到-->套餐
出个套餐,美味套餐(上校鸡块,可乐,薯条)
我现在要点单 我只需要干嘛 美味套餐来一百份

程序:
    把一些会经常用到代码保存起来,取个有意义的名字,以后要用直接调用就OK
    
变量:保存一个/多个数据
函数:保存的是一段或者多段代码
    
其实函数我们也并不陌生
print (输出函数)  input(输入函数) 内置函数

函数的优点:
    1.遇到重复代码时,可以定义为函数,省事
    2.修改起来比较方便
    
本质:写好的一些代码,可以实现特定的功能,取个好记的名字保存起来方便使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

二、函数基础

函数的命名规则和变量是一样的:
    1.由数字,字母,下划线组成
    2.不能数字开头,不能有其他特殊符号
    3.区分大小写 fun Fun
    4.不能用关键字/内置函数 print input type
    5.见名知意
    
函数如果没有特别作用,没想好别的名字 可以取名fun

函数的使用分为两步
#先定义再调用,程序是从上往下执行
    1.声明-->define-->def
    2.使用,调用函数
1
2
3
4
5
6
7
8
9
10
11
12
13

2.1定义函数&调用函数

1.定义函数
	def 函数名():
        代码内容
      
    def fun():
    print('好好学习')
    
调用函数:在函数名后面加个括号,就是调用函数
    函数名()
    fun()
实例:
    #定义函数
    def fun():
        print('好好学习')

    #调用函数
    fun()

2.声明空函数,还没有想好内容,为了防止报错,就先写个pass
	def 函数名():
        pass
    
    def fun_2():
    pass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

三、函数参数

函数里的数据如果是一成不变的,那很鸡肋,函数会接触到各种各样的数据,函数可以根据情况,来接收一些数据,并在函数里处理

让函数里的内容可以更加灵活,数据不是定死的-->函数参数

形参-->没有具体数据,只是先占个位置-->定义阶段
实参-->有具体的数据,在运行时取代形参-->调用阶段

声明带参函数:
    def 函数名(形参):
        代码
        
    def fun(money):
    	print(f'我最喜欢{money}了')
    
调用带参函数
	函数名(实参)
    fun(50)
    fun(100)
    fun(1000000)
一个萝卜一个坑,不要多,也不要少,你定义了几个形参,就传几个实参,否则就会报错
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.1必备参数

有几个形参,就传几个实参,数量要一致
定义时:
    def 函数名(形参1,形参2,..):
        代码
        
调用时:
    函数名(实参1,实参2,...)
    
例:
    def add(num1,num2):
        print(num1+num2)

    add(70,520) #少写多写都会报错
1
2
3
4
5
6
7
8
9
10
11
12
13

3.2默认参数

在声明参数的时候就提前赋好值,作为一个默认的参数

定义时:
    def 函数名(形参1,形参2=值):
        代码
调用时:
    函数名(实参1)
    
例:
    def fun(money,people='陌上'):
        print(f'{people}最喜欢{money}了')

    fun(100)
    fun(50)
    fun(50,'许总') #不会报错,但是学_恒会覆盖原来的陌上
    
注意:赋值的默认参数要放右边,不能放左边
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.3不定长参数(1)

有的时候可能出现,不清楚这个函数会接收多少个参数,这时候就用不定长参数
不定长参数可以一次性接收多个数据, 接收到的数据为元组类型
不定长参数的表现形式:*
参数名是不固定,但是正常规范命名都是取名为*args

定义时:
    def 函数名(*args):
        代码
调用时:
    函数名(值1,值2,值3)
    
例:
    def room(*args):
        print(args)
        print(args[1])

    room('李白','王维','杜甫','杜牧','老子','孔子')
    
    #想好了具体传什么形参的时候,剩下的还没有想好,也可以结合不定长参数1使用
    def message(name,age,*args):
        print('''
        -----个人信息表-----
            姓名{}
            年龄{}
        '''.format(name,age))
        print(args) #('李白', 25, 8.8, (0, 1))
        print(args[0]) #李白
        print(args[1:]) #(25, 8.8, (0, 1))
        print(args[1::2]) #(25, (0, 1))

    message('陌上',18,'李白',25,8.8,(0,1))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

3.4不定长参数(2)

可以一次性接收多个数据,接收的数据类型为键值对,得到的数据为字典类型
不定长参数2的表示形式为:**
参数名同样不固定,但最好叫**kwargs

定义时:
    def 函数名(**kwargs):
        代码
调用时:
    函数名(键=值,键=值) #键不用加引号
    
实例:
    def fun_2(**kwargs):
        print(kwargs)
    fun_2(name='陌上',age=18)
    
    def grade(C,M,**kwargs):
        print(f'Chinese{C},Math{M}')
        print(kwargs)
    grade(98,99,java=100,python=500)

    def fun_3(a,b,*args,**kwargs):
        print(a*b)
        print(args)
        print(kwargs)
    fun_3(5,10,java=100) #a对应了5,b对应了10,java=100对应了**kwargs,*args没有传值,所以是一个空元组
    fun_3(5,10,5,6,7,8,9,java=100)
    
注意:不定长参数1必须要在不定长参数2前面
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

四、返回值(return)

def add(num1,num2):
    print(num1+num2)
add(520,70)
a=add(520,70)
# b=a+1 #报错 不支持无类型跟整型相加
# print(b)
print(a)

如果没有定义返回值 会返回一个None空

在函数里,一个数据只是用print输出.那就只能看,不能用,如果你想要用这个数据,需要的是return来返回,而不是print输出

return 返回值
把值返回给函数本身,可以用来使用 返回值一般是结合函数参数来使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14

那现在我们要用一个有返回值的函数怎么做?

1.定义一个带有return返回值的函数
	def 函数名():
        return 数据
2.输出返回值内容:把函数名()用print包裹起来,这个动作就会达到目的是:
        1.运行函数,2.输出函数的返回值
        print(函数名())
        
 		实例:
            def fun(a,b):
                return a+b
            fun(3,5) #直接调用函数 不会显示出返回值的内容
            print(fun(3, 5)) #所以要打印返回值需要print
            
返回值可以有多个,并且也可以输出多个返回值,得到的类型是元组类型
	def 函数名():
        return 返回值1,返回值2,...
    def fun3():
        return '么么哒',1,True,[1,2,3]

    print(fun3())
    
得到的返回值还有一种用法是可以把函数返回值赋值给变量
	变量名=函数名() #把函数返回值赋值给变量
   	例:
        def fun(a,b):
            return a+b
        fun(3,5) #直接调用函数 不会显示出返回值的内容
        print(fun(3, 5))
        a=fun(3,5)
        c=a+10
        print(c)
        
注意:
    在return后面的代码是不会执行的,因为函数执行到return就会结束
    def talk():
        print('大家留下加班')
        print('没有加班费')
        return 'ok'
        print('加你个大头鬼')
    talk() #直接调用函数不会显示出返回值的内容
    print(talk()) #输出返回值内容
    print(talk) #内存地址
    
返回值细节:
    1.返回值的类型是不限的,int/str/folat/list/dict都可以,也可以返回一个函数
    2.返回值的数量数不限的,可以返回多个数据,得到的数据是元组类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

五、内置函数(基础篇)

python自带的一些功能函数
	序列类型/散列类型方法
    数据类型转换 int() str() list()
    
特点:
    1.都有一个小括号
    2.每个函数都有自己的功能
    
print():输出函数
input():输入函数
type() : 获取数据类型函数
len(): 获取数据长度函数(里面有多少个元素)    
    
min(): 获取最小值函数
max(): 获取最大值函数
sum():  获取数据的和 函数 
    
li = [1, 2, 3, 4, 5, 6, 8, 9]
print(max(li)) #最大值
print(min(li)) #最小值
print(sum(li))#和
print(len(li)) #长度
函数命名不要取名为内置函数的名字!!!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

六、文档字符串

基于函数的注释,看起来和注释差不多,但是可以被调用,在学函数是,更推荐使用文档字符串,里面可以写
	1.这个函数是干嘛用的
    2.这个函数参数是干嘛用的
    3.返回值是干嘛用的
    
def add(a,b):
    '''
    我是一个加法函数
    :param a:int型
    :param b:float型
    :return:a+b
    '''
    return a+b
print(add(2,2.3))
print(add.__doc__)
print(print.__doc__)   
输出方式:注意是两个下划线
    函数名.__doc__
    print(print.__doc__) 
    print(input.__doc__)
	print(max.__doc__)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

day10复习拓展

第6-9节课复习

流程控制语句
	三大执行方式:
        1.顺序执行:程序从上往下依次执行
        2.选择执行:根据条件满足与否,执行对应的代码
        3.循环执行:根据条件满足与否,循环执行对应的代码
            
if 选择执行/分支语句
	分支语句分为三种
    	1.单分支--if--如果满足if条件就执行对应代码
        	if 判断条件:
                执行语句
                
        2.双分支--if,else--如果满足if条件就执行if里的代码,否则执行else里的代码
        	if 判断条件:
                执行语句
            else:
                执行语句
                
         3.多分支--if,elif,else--如果满足if条件就执行if里的代码,不满足就接着判断是够满足elif的代码,满足就执行elif的代码,elif也不满足才执行else的代码
        	if 判断条件:
                执行语句
            elif 判断条件:
                执行语句
            else:
                执行语句
       一组分支里面,if和else只能有一个,elif可以有多个
    
if还有个特性  判断条件有值就执行  没值的情况就不执行
	有值为真 没有值为假(0,None,'',[],{},set())
	
流程控制语句中代码块的概念,通过tab缩进来控制,一般一个tab是4个空格

循环语句:
	判断条件是否满足,如果满足条件就循环执行,不满足是结束循环
	死循环--一直执行,不会结束的循环
	
	while 循环:
		语法:
			while 循环条件:
				执行语句
				更新语句 #如果你条件不更新,那就会一直死循环
				
			num=1
            while num<=100:
                print(666)
                num+=1
                
    for 循环:在(1)循环已知次数 (2)遍历数据 都比while更高效
    	语法:
    		for 变量 in 可迭代对象: #可迭代对象理解为有多个数据的值即可,这里的变量取名为i
    			执行语句
    			
    		talk='伊诺老师提前祝大家端午安康'
            for i in talk:
                print(i)
                
            for i in range(10) #循环10次,i的值为0-9
            for i in range(1,11) #循环10次,i的值为1-10
            for i in range(1,11,2) #循环5次,i的值为1,3,5,7,9 步长为2
            range的起点默认为0.终点到他的前一位
            
            break--直接结束本轮循环
            continue--跳过本次训话
            break 和continue 一般结合循环里的if来使用 如果满足条件就break
            pass --没有写好内容 为了防止报错 可以先写个这个
            
序列类型方法:
    方法有很多,不需要死记硬背,要用的时候根据需求来查
    1.列表的方法中,增删改直接写,不需要print,查需要print
    2.元组只有查询方法,因为元组不支持修改,所以元组的内容要结合print来输出
    3.字符串的数据是不可变的,所以字符串也要结合print来输出
    
	用的比较多的方法:
    	append--列表追加数据
    	insert--列表插入数据
    	index--查询数据下标
    	replace--字符串修改数据
    	
散列类型(set集合,dict字典):
	1.可以存储多个数据
	2.里面的数据没有顺序概念(没有下标)
	3.数据不能重复
	
set-->集合,表示形式为用大括号包裹起来的数据,里面的数据用逗号隔开,集合里不会存储重复数据
	set1 = {1,1,2,3,5,0,4,7,98,7,7,52,0} #重复数据不会真的存进去
	
	集合可以用来进行简单的逻辑运算
		&交集(两个集合里共用的元素)  
        |并集(两个集合所有元素) 
        -差集(两个集合间,独有的元素)
    集合主要用来:
    	1.数据去重
    	2.进行简单的交并差判断
    	
dict-->字典,示形式为用大括号包裹起来的数据,里面的数据以键值对的方式来存储,里面的数据用逗号隔开
	键值对语法: 键:值 变量名:变量值
	info={
		'姓名':'陌上',
		'年龄':18,
		'美女':True
	}
	用键值对保存的数据,看起来更加清晰明了,所以如果要 保存的数据有明显对应关系,就可以用字典来存储数据
	键是唯一的,值可以是任意类型(数值,序列,散列,函数)
	
	字典的输出方式通过键名输出
	字典名[键名]
	print(info['姓名'])
	
	字典名[键名]=值 #修改这个键的值
	info['美女']='丑女'
	
函数(function):
	函数的概念就是把一些经常用到的 代码保存起来,取个名字,以后要用功能,直接调用即可
	类似于生活中套餐
	函数的使用分为两步:1定义(define) 2.调用
	
	定义函数:
	<1>定义一个普通函数
		def 函数名():
			代码
		def fun():
			print('好好学习')
			
	<2>定义一个空函数
		def 函数名():
			pass
		def fun2():
			pass
			
	<3>定义一个带有返回值的函数
		def 函数名():
			return 返回值
		def fun3():
			return 123
			
	<4>定义一个带参函数		
		def 函数名(参数):
			代码
		def fun4(name):
			print(f'{name}好好学习')
			
	调用函数:
		1.直接调用函数
			函数名()
			fun() #执行fun里的代码
			
		2.输出返回值/函数内存地址
			print(函数名) #输出函数内存地址
			print(fun3)
			print(函数名())
			print(fun3())
			
		3.调用带参函数:
        	fun4('陌上')
        	
	函数参数:
		形参:没有具体的值,只是先占个位置--定义时
		实参:有具体的值,在调用时取代形参运行--调用时
		
		<1>必备参数-- 形参,实参数量要一致,一个萝卜一个坑
			def fun(a,b):
                print(a,b)
            fun(1,2,)
            
         <2>默认参数-- 在定义形参时,就给里面的某个变量赋值,就可以不用传参,赋值只能给右边的数据赋值 
         	def fun_2(age,name='陌上'):
                print(age,name)
            fun_2(18)
            fun_2(18,'帅哥') #帅哥覆盖原来的默认参数值陌上
            
         <3>不定长参数1-- 在不清楚要接收几个数据的情况下可以用它,一次性接收多个数据数据,接收的数据类型是元组类型数据,表现形式为  *参数名 一般取名为*args   
         def fun_3(*args):
            print(args)
            print(type(args))
        fun_3(66,888,True,'陌上')
        
        <4>不定长参数2-- 在不清楚要接收几个数据的情况下可以用它, 一次性接收多个数据数据  ,可以接收键值对数据,接收的数据类型是字典类型数据,表现形式为  **参数名,一般取名为  **kwargs
        def fun_4(**kwargs):
            print(kwargs)
            print(type(kwargs))
        fun_4(python=90,math=80,age=18,name='陌上') #键不用打引号

return返回值:
	一个数据如果使用print,那就是只是作为输出,是只能看,不能用
	所以一个数据想被继续使用,就是通过return的方式,把他返回出去
		返回值的默认值为None 为空
		return后面的代码是不会再运行
		返回值的数量/类型是不限的
		
文档字符串:
写在函数里的注释,可以被调用,里面写的是函数的相关说明.参数/返回值/这个函数的说明
	def 函数名():
        """文档字符串的内容"""
    可以通过函数名.__doc__的方式输出 文档字符串的内容
    print(print.__doc__)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195

函数注意—高内聚低耦合

为什么要分开写  我把加减乘除写到一个函数里不可以吗???--避免一个错,全部错

我把加减乘除函数都写在了一个函数里面,然后里面的除法功能出错了,我这个函数还能用吗?--不能使用

把加减乘除函数分开写在4个函数里,然后里面的除法功能出错了,我这个函数还能用吗?可以先把他屏蔽 注释  也不会影响其他功能

专注做好一件事 彼此联系不要过于紧密

高内聚-->一个程序里/函数里做的事情尽量统一/专一,一个函数做好一个功能就可以了,而不是一个函数里写一堆的功能 容易一个错 整个错

低耦合-->程序与程序之间,函数与函数之间的关联不要过于紧密 各做隔得 ,避免一个错 全部错
1
2
3
4
5
6
7
8
9
10
11