准备

  • python解释器:解释代码,把python计算机语言翻译给计算机认识
  • 编辑器:编写代码,有自动补全以及自动提示的功能
1
2
3
4
1、python解释器下载地址
https://www.python.org/downloads/
2、pycharm编辑器下载地址
pycharm官网

1、其实安装了解释器之后就可以在命令行操作python了,而编辑器的话用起来会方便一点

2、在编译器中使用

1
在settings里面设置python解释器

基础

1
2
3
# 查看python中的关键字
import keyword
print(keyword.kwlist)

缩进,比如说函数体,不一定非得是4个空格,有就可以,但是为了规范,一般都是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
# 单行语句变多行语句
a = 1
b = 2
c = 3

d = a + \
b + \
c

print(d)

a = '张永记' \
'学习python'

b = "张永记" \
"learnpython"

c = """
zyj
学习
python
"""

见上面的使用示例

元组、列表和字典,多行不需上述的要求

1
2
3
4
5
6
7
8
9
10
11
# 单行注释使用

'''
1、多行注释的使用
2、见这个示例
'''

"""
1、多行注释的使用
2、见这个示例
"""
1
2
3
4
5
输入函数 input()
输出函数 print()

password = input('请输入你的密码:')
print(password)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
转义

提出:print("我的名字"你知道吗"")

解决方法,转义
print("我的名字\"你知道吗\"")

\n 换行
\t 制表符,补全占位,从前向后每四个分组,到达\t时补齐四个字符
示例:print(hell0\t000) 'hell' 'o ' 此时o后面有三个空格
\r 覆盖,\r后面的内容覆盖\r前面的内容
\b 删除,将\b前面的一个字符删掉
\\ 输出\,要进行转义
r\R 使转义不起作用
示例:print(r"我是\n你的朋友")
1
2
3
4
5
多个变量同时赋值

a,b,c = 100,200,300

print(a,b,c)
1
2
3
4
5
6
7
8
9
10
# 运算符

+ - * /

除法运算,向下取余 2//4 0 0.5向下取整为0
取模值 7%3 1
幂运算,返回乘方结果 2**3 8

# 比较运算符
> < >= <= == !=
1
2
3
4
5
python里的逻辑连接词

and A and B
or A or B
not not A

python的空值 None,None表示什么也没有,不能参与运算

string

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
name = "我觉得你真的很不错!"

1、字符串的切片

print(name[0:3]) 我觉得 取左不取右
name[:3] 左边不写 默认从0开始 最左边
name[3:] 右边不写 默认从-1开始 最右边
name[:] 都不写 默认整个字符串 整个字符串

从左往右从0开始,从右往左从-1开始,name[-3:-1],规则依然是取左不取右,其余规则类似

切片[开始:结尾:步长],取左不取右

name[::-1],字符串进行反转 !错不很的真你得觉我

2、下标取值

name[0] 我 从左往右从0开始,从右往左从-1开始

3、字符串拼接,用 + 号拼接

a = '我爱你'
b = '来不及了'

print(a + b) 我爱你来不及了

join方法的使用
a = '我爱你,'
b = '来不及了'
print(a + b) 我爱你,来不及了

a = '我爱你'
b = '来不及了'
f = ','.join((a,b))
print(f) 我爱你,来不及了

4、字符串的格式化

# 最初的样子
s = "大家好,我的名字是{},我的职务是{},很高兴认识大家".format('zyj', '学习委员')

# 后续操作
s1 = "大家好,我的名字是{},我的职务是{},很高兴认识大家"
s1.format('zyj', '学习委员')

# 0、1等等有对应关系
s2 = "大家好,我的名字是{1},我的职务是{0},很高兴认识大家".format('zyj', '学习委员')
s2.format('zyj', '学习委员')

5、字符串的常用方法

5.1、find(查找的内容,区间的起点,区间的终点)
找到相应区间内,某内容第一次出现的下标,找不到返回值为-1,区间不写则默认为整个字符串

s = 'ilovelearning'
print(s.find('l',2,12))

5.2、count(查找的内容,区间的起点,区间的终点)
找到相应区间内,某内容出现的次数,找不到返回值为0,区间不写则默认为整个字符串

s = 'ilovelearning'
print(s.count('l',2,12))

5.3、replace(旧的内容,新的内容,替换的次数)
用某一新的内容替换旧的内容,从左向右替换多少次,默认全部替换

s = 'ilovelearning'
print(s.replace('l','WBG',1))

5.4、upper()和lower()
将某一字符串里的英文字母全部转换成大写或者全部转换成小写

5.5、split(切分标识,切分次数)
按照某一内容,按照分割次数将字符串进行切分

s = 'ilovelearning'
print(s.split('l',1))

5.6、strip(str)
用于去除字符串首尾的str,注意只能是操作首尾的,对于内部的无能为力

5.7、传统的格式输出和F表达式
%s 字符占位
%d 整型占位
%f 浮点占位

s = '我%s你'%(love)

F表达式

name = 'zyj'
job = '学习委员'

s = F'我的名字是{name},我的职务是{job}'
print(s)

5.8len(字符串)
求字符串的长度

s= 'iloveyou'
print(len(s))

5.9format格式输出
:.2f小数点后两位
:.2%百分数情况下小数保留两位

s = 0.236

print('失败的概率是{:.2f}'.format(s))

print('失败的概率是{:.2%}'.format(s))

多个参数时的使用方式,冒号前面的数字与参数的下标对应
print('失败的概率是{1:.2f}'.format(s, x))

列表

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
1、列表里面可以是任意的数据类型,下标从零开始

2len(列表s) 求列表s的长度
列表里的值是可以更新的,直接重新赋值就可以了

3、列表的加法和乘法
list1 = [1,2,3,4]
list2 = [20,60,40]

print(list1 + list2)
[1,2,3,4,20,60,40]
print(list1 * 5)
[1,2,3,4,1,2,3,4,1,2,3,4,1,2,3,4,1,2,3,4]
注:字符串的乘法也是重复n遍

4、列表的切片规则和字符串的切片规则一样,参考上文

5、列表的方法
5.1del(列表名或者列表中具体的元素)
a = [1,2,3]

del(a) 注意删除后,输出a是a未定义报错,而不是输出None
del(a[1]) 输出结果:[1,3]

5.2、append(待添加的内容)
将待添加的内容添加到列表的末尾
a = [1,2,3]

a.append(4)

print(a) 输出结果:[1,2,3,4]

5.3、insert(插入的位置,插入的对象)
将插入的对象插入到相应的位置

a = [1,2,3]

a.insert(2,'你好')

print(a) 输出结果:[1,2,'你好',3,4]

5.4、clear()
将列表清空

a = [1,2,3]

a.clear()

print(a) 输出结果:[]

5.5、remove(移除的元素)
将移除的元素在列表中移除,若列表中有重复的元素,只会移除匹配到的第一个

a = [1,2,3,4]

a.remove(1)

print(a) 输出结果:[2,3,4]

5.6、pop(移除元素的下标)

a = [1,2,3,4]

a.pop(1) 函数的返回值是移除的数据

print(a) 输出结果:[1,3,4]

5.7、index(查找对象,区间起始值,区间终点值)
返回在指定区间内与查找对象匹配的数据下标,只会返回第一次查找到的下标

a = [1,2,3,4,1]

r = a.index(1,1,) 函数的返回值是移除的数据,注意取左不取右

print(r) 输出结果:4

5.8、reverse()
将列表反向

5.9、extend(待添加的元素)
将待添加的元素依次加入到先前的列表中

a = ['zyj', 'gzp', 'xcy']
b = [1,2,3,4]

a.extend(b)

print(a) 输出结果:['zyj', 'gzp', 'xcy', 1, 2, 3, 4]

5.10、copy()

a = ['zyj', 'gzp', 'xcy']

b = a

del a[0]

print(b) b与a上发生的操作一致,输出结果:['gzp', 'xcy']

a = ['zyj', 'gzp', 'xcy']

c = a.copy()

del a[0]

print(c) c只是a的备份,对a操作并不会影响c,输出结果:['zyj', 'gzp', 'xcy']

5.11、sort()
对同类型的列表数据进行排序

a = ['zyj', 'gzp', 'xcy']
a.sort()
print(a) 排序的标准是ASCII码,由小到大排序

a.sort(reverse = True)
print(a) 设置上述参数后,排序结果为由大到小排序

5.12、count(查找对象)
查找列表中查找对象出现的次数并返回

a = [1,2,3,5,1,2,3,1,4]
r = a.count(1)
print(r)

元组

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
1、元组的元素是不可以修改的

2、通过元组下标获取相应的数据

3、切片操作与上述字符串和列表类似

4、元组的拼接 +

a = ('zyj', 'gzp', 'xcy')

b = ([1,2,3],"你好呀", 150)

c = a + b

c[3][0] = 6

print(c)

最外面的c是元组,它的内容是不可以修改的,但是里面的内容的内容是可以修改的数据的话是可以修改的

5、求元组的长度
len(元组)

6、求元组中的最大值和最小值
max(元组)、min(元组) 判断大小的依据是ASCII码

7、一些注意事项

a = (1,2,3,4) 元组
a = 1,2,3,4 元组

a = (10) 不是元组
a = (10, ) 元组
注:乘号的使用,就是将元组里面的内容重复n遍

集合

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
1、集合中的元素是无序的、是唯一的

2、创建集合的两种方式

2.1、使用set()方法
()里面的参数可以是,字符串、列表、元组、字典

a = set("12345600")

b = set([1,2,3,4])

c = set((1,2,3,4,5))

d = set({
"姓名": zyj,
"年龄": 18
})
字典创建的集合,集合里面是键名

2.2、直接使用{}创建
{}里面只能是字符串、数字和元组,不能是列表和字典

e = {"love", 1 ,(1,2,3)}

3、集合的作用

3.1、列表的去重
a = set([1,2,3,1,1,1])
print(a)

3.2、元组的去重
b = set((1,1,1,1))
print(b)

3.3、字典键名的去重
c = {
"姓名": "zyj",
"姓名": "zjm"
}
f = set(c)
print(f)

3.4、字符串的去重
e = set("12135134444111")
print(e)

4、add(添加内容)
将添加的内容添加到集合中,这个内容是数字、字符串、元组
a = {1,2,3}
a.add(4)
print(a)

5、update()
将集合合并
a = {1,2,3}
b = {'e', 'd'}
a.update(b)
print(a)

a发生更新,b的内容没有发生变化

6、删除操作
remove、pop、discard

a = {"python", 123, "xuexi"}

a.remove(123)
print(a)
将特定内容删除,没有的话报错

a.pop()
print(a)
随机的删除集合中的一个元素

a.discard(123)
print(a)
将特定的内容删除,没有的话不会报错

7、集合的交集 $ 并集 |
s1 = {1,2,3,4}
s2 = {1,2,5,6}
s3 = s1 $ s2
s4 = s1 | s2

print(s3)
print(s4)

字典

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
1、字典的定义方式

键名可以是元组、字符串和数字,是不可变的数字类型

1.1、使用{}方法
a = {
"姓名": "zyj",
"年龄": "18"
}

1.2、使用dict()方法
b = dict((["年龄","18"],["姓名","zyj"]))

1.3、注意
c = {} 一个空字典
d = set() 一个空集合

2、字典的增删改查功能

d = {"姓名": "zyj", "年龄": 18}

d["职务"] = "学习委员"

del d["职务"]

d["年龄"] = 20

d["姓名"]

3、字典的方法
3.1、get(键名,默认值)方法
获取键名对应的键值

r = d.get("姓名")
有则返回结果,无则返回None,如果写了默认值无则返回默认值

3.2、keys()方法
获取字典中的所有键名

r = d.keys()

3.3、items()
以列表的形式返回字典中的所有键值对,每一个键值对用一个小括号

r = d.items()

3.4、values()
返回字典中的所有键值

r = d.values()

3.5、clear()
清空当前的字典

d.clear()

3.6、copy()
和之前的用法一致,创建副本

3.7、fromkeys(参数一,参数二)
用于创建一个新的字典,参数一可以是列表、元组和集合,参数二可以是任意的类型

d = {}
r = d.fromkeys(("姓名","年龄"), 6)
r1 = d.fromkeys(("姓名","年龄"), (1,2))

参数一中成为键名的每一个键对应的键值都是参数二

3.8、pop()
从字典中删除指定的键,并返回改键对应的值

r = d.pop("姓名")

3.9、popitem()
从字典中删除最后一项,并以元组的形式返回对应的键和值

r = d.popitem()

3.10、setdefault()
设置键的默认值,若该键已存在则忽略,不存在则添加该键和值

d.setdefault("职务","学习委员")

3.12、update()
a.update(b)

用b中的键值对更新a中的键值对,如果a和b都有,则用b更新a,如果a中没有,则添加进去

成员检测和对象是否相同

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1、成员检测,判断对象是否在某一序列(列表,字符串、元组、字典)中,在则返回True,反之则返回False

in
not in

a in ('a','c',1) True

注:字典的话,只能判断键名,不能用于判断键值

2、判断两个对象是否相同,相同返回True,反之则返回False

is
not is

a = "姓名"
b = "年龄"

a is b False

注:元组 / 数字 / 字符串 表面一样,就完全一样 不可变数据类型
列表 / 字典 / 集合 表面一样,其实不一样,其实不是同一个对象 可变数据类型

数据类型转换

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
1、数据类型

字符串类型String
数字类型Number
整型int
浮点型float
布尔型Bool
表类型List
元组类型Tuple
字典类型Dictionary
集合类型Set

2、不同的数据类型之间是不允许运算的,所以要进行数据类型转换
精度等级:布尔 < 整型 < 浮点

3type(变量) 检测当前变量的数据类型

4str(变量) 将当前变量强制转换为字符串类型
所有类型都可以转化成字符串类型

5int()和float()
将其他类型的数据转换成整型(只取整数部分),将其他类型的数据转换成浮点型

*数字类型之间可以互相转换
*只有字符串可以转换成数值类型,并且字符串中的元素必须都为数字,否则不能转换

6bool()
6.1、容器类型转布尔类型
容器类型:字符串、列表、元组、集合、字典
非容器类型:数字,布尔

容器为空 ---> False
容器不为空 ---> True

6.2、数值类型转布尔类型
0或则0.0 ---> False
其它 ---> True

7list()

* 数字类型是非容器类型,不能转换成列表

* 字符串会将字符串中的每一个字符转换成列表的元素
b = "abcd1234"
print(list(b))
['a', 'b', 'c', 'd', '1', '2', '3', '4']
* 元组会将元组中的每一个元素转换成列表的元素
c = ('1', '2', "abc")
print(list(c))
['1', '2', 'abc']
* 字典会将键名转换成列表的元素
d = {
"姓名": "zyj",
"年龄": 18
}
print(list(d))
['姓名', '年龄']
* 集合本身是无序的,转成的列表也是无序的
e = {1, 2, 5, 9, 0}
print(list(e))
[0, 1, 2, 5, 9]

8tuple()

* 数字是非容器类型,不能转换成元组

* 会将字符串中的每一个字符转换成元组的元素
b = "abc123"
print(tuple(b))
('a', 'b', 'c', '1', '2', '3')
* 会将列表的每一个元素转换成元组的元素
c = [1, 2, 3, 'a']
print(tuple(c))
(1, 2, 3, 'a')
* 会将字典的键名转换成元组的元素
d = {
"姓名": "zyj",
"年龄": 18
}
print(tuple(d))
('姓名', '年龄')
* 将集合转成元组时是无序的,因为集合本身就是无序的
e = {1, 2, 5, 9, 0}
print(tuple(e))
(0, 1, 2, 5, 9)

9set()
数字类型不是容器类型,不可以转换成集合
字符串、列表、元组转成集合后是无序的,字典会将键名转换成无序的集合

10dict()
数字、字符串、集合是不能转换成字典的

列表和元组类型的都可以转换,但是必须是等长的二级容器,子容器中的元素的个数必须是2

a = [["1","2"],["姓名","zyj"]]

print(dict(a))

b = ((1,2),("张永记","学习委员"))

print(dict(b))

11isinstance(对象,数据类型)
判断当前对象是否是括号中的数据类型,若是,则返回True;否则返回False
print(isinstance(1,int))

结构

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
1、条件结构
if
......
elif
......
else
......


elif可以没有

2、通过不使用下标的方式遍历字符串、列表、元组、字典、集合

for i in 字符串、列表、元组、字典、集合:
print(i)

3、遍历字典的键和值

d = {
"姓名":"zyj",
"职务":"学委"
}

for i in d.items():
print(i)

4range(区间起点,区间终点,步长)
for i in range(0,6,2):
print(i)

5while循环

6、循环的关键字
* 循环一旦看到break立刻退出,循环结束
* continue用于跳过当前循环块中剩余的语句,然后进行下一轮循环

7pass
空语句,是为了保证程序结构的完整性
它用于那些语法上必须有什么语句,但是程序什么也不做的场景

函数

1
2
3
4
5
6
7
1、函数的样式

# 传入参数可以是任何的数据类型,函数参数可以有默认值
def 函数名(参数列表):
函数体

2、默认参数后面也必须是默认参数