python学习之函数，列表和元组，字典

函数

默认参数

和c++一样拥有并支持默认参数

关键字参数

整理

函数的定义
函数的调用
函数的参数传递过程
函数的执行流程：

列表

列表和元组大部分功能是差不多的，但是：
列表是可变的，
元组是不可变的

一、创建列表

# 1.使用字面值来创建
# [] 就表示一个空的列表
# a=[]
# 2.使用list()来创建
# b=list()
# 这两种类型都是 list

# 3.可以在创建列表的时候，在[]中指定列表的初始值
# 元素之间使用,来进行分割
# a=[1,2,3,4]
# print(a)
# 输出[1, 2, 3, 4]

# 4.C++/java中要求一个数组里面只能存放相同类型的变量
# 列表无要求
# a=[1,'hello',True,[3,4,5]]
# print(a)
# 输出：[1, 'hello', True, [3, 4, 5]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

二、访问下标

# 1.需要使用[]下标访问运算符
# a=[1,'hello',True,[3,4,5]]
# print(a[2])
# print(a[3])
# 输出：
# True
# [3, 4, 5]

# 2.使用下标修改列表
# a=[1,'hello',True,[3,4,5]]
# a[1]=3
# print(a)
# 输出：[1, 3, True, [3, 4, 5]]

# 3.超出下标有效范围，就会出现异常

# 4.可以使用 len 来对其进行 获取长度
# a=[1, 3, True, [3, 4, 5]]
# print(len(a))
# 输出：4
# len可以传 字符串，列表，元组，字典，自定义的类

# 5.python中的下标可以写成负数
# a=[0,1,2,3,4,5,6,7]
# print(a[-1]) # 7
# print(a[len(a)-1]) # 7
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

三.切片操作

# 1.基本使用
# a=[1,2,3,4,5]
# print(a[2:4])
# [3, 4]
# 即打印出了a的[2,4)的数据

# 2.省略边界
# a = [1,2,3,4,5]
# print(a[2:])
# 输出：[3, 4, 5]
# print(a[:4])
# 输出：[1, 2, 3, 4]
# 即：可以省略前 后 还可以全部省略

# 3.带有步长的切片操作
# a = [1,2,3,4,5,6,7,8,9]
# print(a[::1])
# 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]
# print(a[::2])
# 输出：[1, 3, 5, 7, 9]

# 4.步长也可以是负数
# 即倒着取

# 5.当切片中的范围超出有效下标之后
# 不会出现异常，而是尽可能将符合要求的数据获取到
# 总结：
# [开始位置:结束位置:步长]
# [开始位置:结束位置)
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

四、遍历

# 把一个列表里面的每个元素，都依次取出来，并进行某种操作
# 1.使用for循环
# a=[1,2,3,4,5]
# for elem in a:
#     print(elem)
# element:元素

# 2.使用for循环，下标的方式
# a=[1,2,3,4,5]
# for i in range(0,len(a)):
#     print(a[i])



1
2
3
4
5
6
7
8
9
10
11
12
13
14

五、插入

# 1.尾插
# a=[1,2,3,4,5]
# a.append(6)
# print(a)
# 输出[1, 2, 3, 4, 5, 6]
# a.append('hello')
# print(a)
# 输出：[1, 2, 3, 4, 5, 6]

# a=[1,2,3]
# b=[2,3,4]
# a.append(b)
# print(a)
# [1, 2, 3, [2, 3, 4]]

# 2.insert
# a=[1,2,3,4]
# a.insert(1,'hello')
# print(a)
# [1, 'hello', 2, 3, 4]
#
# 当在超出范围的地方插入的时候
# a=[1,2,3,4]
# a.insert(10,'hello')
# print(a)
# [1, 2, 3, 4, 'hello']
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

六、查找

# 1.使用in，来判断某个元素是否在列表中
# a=[1,2,3,4]
# print(1 in a)
# print(5 in a)
# True
# False

# 2.使用not in 来判断是否不存在
# a=[1,2,3,4]
# print(1 not in a)
# print(5 not in a)
# False
# True

# 3.使用index方法，来判定当前列表中的位置，得到一个下标
# a=[1,2,3,4]
# print(a.index(2))
# print(a.index(5))
# Traceback (most recent call last):
#   File "C:\Users\wyw15\PycharmProjects\pythonProject\learn3.py", line 181, in 
#     print(a.index(5))
# ValueError: 5 is not in list
# 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

七、删除

# 1.使用pop删除列表最末尾的元素
# a=[1,2,3,4]
# print(a.pop())
# print(a.pop())
# print(a)
# 4
# 3
# [1, 2]

# 2.使用pop删除任意位置的元素
# a=[1,2,3,4]
# print(a.pop(1))
# print(a)
# print(a.pop(2))
# print(a)
# 2
# [1, 3, 4]
# 4
# [1, 3]

# 3.使用 remove 方法，可以按照值来进行删除
# a=[1,2,1,4,2,3,4]
# print(a.remove(1))
# print(a)
# print(a.remove(2))
# print(a)
# None
# [2, 1, 4, 2, 3, 4]
# None
# [1, 4, 2, 3, 4]

# 上述对字符串列表同样使用

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

八、拼接

# 1.正常相加
# a=[1,2,'hello',' ']
# b=['world','!']
# print(a+b)
#
# c=a+b
# print(c)

# 2.使用 extend
# a=[1,2,3,4,5]
# b=[2,3,4,6,7]
# a.extend(b)
# print(a)
# print(b)
# [1, 2, 3, 4, 5, 2, 3, 4, 6, 7]
# [2, 3, 4, 6, 7]

# 3.使用append
# a.append(b)
# print(a)
# [1, 2, 'hello', ' ', 'world', '!']
# [1, 2, 'hello', ' ', 'world', '!']
# [1, 2, 'hello', ' ', ['world', '!']]

# 4.使用 +=
# a=[1,2,3,4,5]
# b=[2,3,4,6,7]
# a+=b
# print(a)
# [1, 2, 3, 4, 5, 2, 3, 4, 6, 7]

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

元组

1.创建元组

# a=()
# print(type(a))
# b=tuple()
# print(type(b))
# 
# 

# 创建元组的时候，指定初始值
# a=(1,2,3,4,5,'hello')
# print(a)
# (1, 2, 3, 4, 5, 'hello')
1
2
3
4
5
6
7
8
9
10
11

2.支持列表的一些操作

# 
# 2.1通过下标来访问元组
# a=(1,2,3,4,5,'hello')
# print(a[3])
# print(a[-1])
# print(a[300])
# 4
# 3
# 元组的下标超出异常

# 2.2切片
# a=(1,2,3,4)
# print(a[1:3])
# (2, 3)

# 2.3使用for循环遍历元素
# a=(1,2,3,4,5,6,7,8)
# for elem in a:
#     print(elem)

# for i in range(1,len(a)):
#     print(a[i])

# 2.4使用in来判断是否存在
# a=(1,2,3,4)
# print(2 in a)
# print(a.index(2))
# True
# 1

# 2.5使用 + 来拼接两个元组
# a=(1,2,3)
# b=(2,3,4)
# print(a+b)
# (1, 2, 3, 2, 3, 4)

# 2.6 只能支持 “读”操作，不支持 修改操作
# a=(1,2,3,4)
# a[1]=100
# 报错

# a.append()
# 报错

# a.pop()
# 报错
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

3.当进行多元赋值的时候，其实本质上是按照元组的方式进行工作的

# def getPoint():
#     x=10
#     y=20
#     return x,y
#
# print(type(getPoint()))
# 

1
2
3
4
5
6
7
8

字典

一、创建字典和查找

# a={}
# print(type(a))
# b=dict()
# print(type(b))
# 
# 
from typing import Dict

# 创建字典时，设置初始值
# a={'id':1,'name':'zhangsan'}
# print(a)
# print(a['name'])
# {'id': 1, 'name': 'zhangsan'}
# zhangsan

# 字典对于key是啥类型，有约束
# 对于value是啥类型，没有约束
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

查找

# 1.使用in来判定某个key 是否在字典中存在
# a={
#     'id':1,
#     'name':'zhangsan'
# }
# print('id' in a)
# print('class' in a)
# True
# False
# in只是判定key是否存在，和value无关
# not in ......................

# 对于字典来说，使用in来获取value是非常高效的：哈希表
# 对于列表来说，使用in比较低效（将整个列表遍历一遍），而使用[]比较高效：红黑树
1
2
3
4
5
6
7
8
9
10
11
12
13
14

二、新增/插入–使用[]新增

# a={
#     'id':1
# }
# a['class']='191'
# print(a)
# {'id': 1, 'class': '191'}
1
2
3
4
5
6

三、修改

# a={
#     'id':1
# }
# a['id']+=1
# print(a)
# {'id': 2}
1
2
3
4
5
6

四、删除

# 使用pop进行删除，根据key删除
# a={
#     'id':1,
#     'name':'zhangsan'
# }
# a.pop('id')
# print(a)
# {'name': 'zhangsan'}
1
2
3
4
5
6
7
8

五、遍历

# 5.1常规遍历 通过for循环遍历出常规字典
# a={
#     'id':1,
#     'name':'zhangsan',
#     'class':'ds123'
# }

# for key in a:
#     print(key,a[key])
# id 1
# name zhangsan
# class ds123
# 字典是一个特殊处理的hash，会根据插入顺序打印出结果

# 5.2取出所有的key 和 value
# 使用keys方法可以获取到字典中的所有key
# a={
#     'id':1,
#     'name':'zhangsan',
#     'class':'ds123'
# }
# print(a.keys())
# print(a.values())
# print(a.items())
# dict_keys(['id', 'name', 'class'])
# dict_values([1, 'zhangsan', 'ds123'])
# dict_items([('id', 1), ('name', 'zhangsan'), ('class', 'ds123')])

# 3.使用多元赋值
# a={
#     'id':1,
#     'name':'zhangsan',
#     'class':'ds123'
# }
# for key,value in a.items():
#     print(key,value)
# id 1
# name zhangsan
# class ds123
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

六、合法的key类型

字典本质是一个hash
在python中专门提供了一个hash函数~
使用hash函数能够计算出一个变量的哈希值
print(hash(0))
print(hash(3.14))
print(hash(‘hello world’))
print(hash(True))
print(hash((1,2,3)))
0
322818021289917443
1161623594216095160
补充这个hash值在 任何电脑上的值都相同
即：3.14：322818021289917443在别的电脑上也是一样的

不能hash的
list不能，字典不能

整理：
不可变的对象，一般就是 可 hash的
可变的对象，一般就是 不可 hash的