入门python必备！！！

1.常用英语词汇！！！

path [ pɑ:θ ] 路径 unexpected [ˌʌnɪkˈspektɪd] 不期望的

class [klɑ:s] 类 usage [ˈju:sɪdʒ] 使用

public ['p ʌblik] 公共的,公用的 version [ˈvɜ:ʃn] 版本

private ['praivit] 私有的,私人的 author [ˈɔ:θə(r)] 作者

static ['stæ tik] 静的;静态的;静止的 int [int] 整型

void [vɔid] 空的,没有返回值的 char [tʃɑ:] 字符型

main [mein] 主要的,重要的 string [striŋ] 字符串类型

system ['sistəm] 系统 float [fləut] 单精度浮点类型

out [aut] 往外,出现,出外 type [taip] 类型

bool ['bu:li:ən] 布尔类型，真假 demo [ 'deməu ] 演示，例子

True [tru:] 真，正确的(成立的) define [dɪˈfaɪn] 定义

False [fɔ:ls] 假，错误的(不成立的) syntax [ˈsɪnˌtæks] 语法

encode [ɪnˈkəʊd] 编码 invalid [ɪnˈvælɪd] 无效的

decode [ˌdi:ˈkəʊd] 解码 indentation [ˌɪndenˈteɪʃn] 缩进

integrated [ˈɪntɪgreɪtɪd] 集成 print [print ] 打印

set [ set] 设置 instance ['instəns ] 实例,情况

reset [r i set] 重新设置 tool [tu:l] 工具

get [get ] 获取,获得 data ['deitə] 资料

multiply [ˈmʌltɪplaɪ] 乘 develop [di'veləp ] 开发

division [dɪˈvɪʒn] 除法 extends [ ik'stends] 继承,延伸,推广

iterable ['itəreibl] 可迭代的 phone [ fəun ] 电话

development [dɪˈveləpmənt] 开发 while [wail]当……的时候

environment [ɪnˈvaɪrənmənt] 环境 interpreter [ɪnˈtɜ:prɪtə(r)] 解释器

count [kaunt] 计数;计算 configured [kən'fɪɡəd] 配置

sum [ s ʌm] 总数,总计 variables ['veərɪəblz] 变量

salary [ 'sæləri ] 薪水 unreachable ['ʌn'ri:tʃəbl] 不能达到的

random ['ræn dəm]随机的 colum [ˈkɔləm] 列

import [im' pɔ:t] 导入,输入 row [rəʊ] 行

if [if] 如果 index [ˈɪndeks] 索引

else [els] 否则 max [ ma: k s] 最大的

switch [switʃ] 判断语句 min [ mi n] 最小的

case [keis]实例,情况 function [ 'fʌŋ k ʃən ] 功能,函数

break [breik] 退出 method [ 'meθə d] 方法

continue [kən 'tinju] 跳出...继续 result [ ri'zʌlt ] 结果

return [ri tə:n] 返回 compare [ kəm' pεə ] 比较

default [di'fɔ:lt] 默认的 temp [ tem p ] 临时工

attribute [əˈtrɪbju:t] 属性 call [ kɔ:l] 呼叫,给...打电话

code [kəud ] 代码,代号,编码 study [ 'stʌdi] 学习,研究

country ['kʌn tri ]国家,国土 work [ wə:k ] 工作,操作

university [ju:ni'və:siti]大学 location [ ləu'keiʃən] 位置(文件在电脑中的位置)

college ['kɔlidʒ] 大学 encoding [in'kəudiŋ] 编码

private ['praivit ] 私有的,私人的 super ['sju: pə] 父类的,超级的,,超类的

null [nʌl] 空,无效的 class member [ 'membə ] 类成员

exception [ ik 'sep ʃən] 异常 class method [ 'meθəd] 类方法

error [erə] 错误 package [ 'pækidʒ] 包

index ['indeks] 角标,索引,指针 car [ kɑ: ] 汽车,小轿车

out of [ a:ut ɔf] 在...之外 color [ 'kʌlə] 颜色

length [ leŋθ] 长度 red [ red ]红色

sort [sɔ:t] 将...排序 blue [ blu: ]蓝色

change [ tʃeindʒ ] 改变，交换 black [ blæ k]黑色

swap [ swɔp ] 交换 white [ hwait ] 白色

half [ hɑ:f ] 一半的,半个的 run [ run] 跑, 运行

search [ sə: tʃ] 搜索,查找 person [ 'pə:sən ] 人

mid [ mid] 中间的 people [ 'pi:pl ] 人,人们

number [ 'nʌmbə ] 数字,号码 age [ eidʒ] 年龄

transition [ træn'ziʃən] name [ neim ] 名字,名称,名誉,名人

object [ 'ɔbdʒi kt ] 对象, 物体 speak [ spi:k] 说话,讲话

show [ ʃəu] 显示,展示 final ['fai nl] 最终的

sleep [sli:p ] 睡, 睡觉, 睡眠 1秒=1000毫秒 finally [ˈfaɪnəli] 最后

single ['siŋgl] 单一的,单独的,单身的,单程的 interface [ 'intəfeis ] 接口

2.语法整理
⼀、萌新语法
输⼊和输出
print()
#打印括号的内容
#第⼀种：不带引号，让计算机读懂括号⾥的内容，打印最终的结果
#第⼆种：带单引号，计算机⽆须理解，原样复述引号中的内容
#第三种：带双引号，作⽤和单引号⼀样；当打印内容中有单引号时，可以使⽤双引号
#第四种：带三引号，实现换⾏
input()
#收集信息
变量的命名
>>>print(1+1) 1
2 2
>>>print('秋水共长天一色') 1
秋水共长天一色 2
>>>print("Let's go") 1
Let's go 2
3
>>> print('Let\'s go') 4
Let's go 5
6
#也可以使用转义字符+单引号(\')来实现单引号 7
5
# 采用转义字符"\n"也可以换行 6
>>>name = input('请输入你的forchange ID：') 1
2
# 使用变量赋值来获取输入的信息 3
1.只能是⼀个词；
2.只能包含字⺟、数字和下划线；
3.不能以数字开头；
4.尽量描述包含的数据内容；
5.不要使⽤python函数名和关键字。
条件判断
条件判断的解释：让计算机知道，在什么条件下，该去做什么。
单向判断
if…
#如果条件成⽴，就执⾏语句
双向判断
if…else…
#条件成⽴执⾏if语句，否则执⾏else语句
>>>number = 34 1
>>>name = 'forchange' 2
>>>list_class = ['基础语法课程'，'爬虫分析初阶'，'爬虫分析进阶'，'自动化办公'] 3
4
#以上number，name，list_class都是是变量名 5
python3.7.4中的关键字（不⽤记，熟悉即可）
False None True and as assert async
await break class continue def del elif
else except finally for from global if
import in is lambda nonlocal not or
pass raise return try while with yield
>>>number = 6 1
>>>if number > 3: 2
... pirnt(number) 3
6 4
5
#注意格式！if后面要加冒号，同时执行语句要缩进四个空格。(空格和tab，我选空格?^^) 6
number = 7 1
if number < 3: 2
pirnt(number) 3
else: 4
number = number - 3 5
print(number) 6
7
#结果输出为4 8
if…else…和if…if…的区别
#if…else…⼀个条件满⾜后就不会进⾏其他判断（if代表的条件和else代表的条件是互斥的）
#if…if…会遍历所有条件，⼀个条件⽆论满⾜还是不满⾜，都会进⾏下⼀个条件的判断
多向判断
if…elif…else
#三个及其以上条件的判断
IF嵌套
if 嵌套
#使⽤if进⾏条件判断，还希望在条件成⽴的执⾏语句中再增加条件判断，即if中还有if，这两
个if⾮平级
⼆、数据类型
数据类型
python常⻅的数据类型：字符串，整数型，浮点数，列表，字典，布尔值，元组。
#if和else是同一层级，不需要缩进。if和else下的执行语句都需要缩进四个空格。 9
grade = 65 1
if 80 <= grade <=100: 2
    print('成绩优秀') 3
elif 60 <= grade < 80: 4
    print('成绩中等') 5
else : 6
    print('成绩差') 7
8
#结果输出为成绩中等 9
grade = 15 1
if 80 <= grade <=100: 2
    print('成绩优秀') 3
elif 60 <= grade < 80: 4
    print('成绩中等') 5
else : 6
    print('成绩差') 7
    if 20<= grade <60: 8
        print('再努力一把，还有救！') 9
    else : 10
        print('你要比以前更努力才行，你可以的！') 11
12
#结果输出为： 13
成绩差 14
你要比以前更努力才行，你可以的！ 15
#注意，嵌套的第二个if缩进了4个空格，表示不同的层级。 16
最基本的数据类型有三种：
字符串str：⽤括号括起来的⽂本（如：'python'、'123'、'⻛变编程'）
整数int：不带⼩数点的数字（如：-1、1、0、520、1314）
浮点数float：带⼩数点的数字，运算结果存在误差（如：-0.15、3.1415、1.0)
以下的数据结构会有⼀节或两节的课程介绍，可轻松上⼿。
列表list：是⼀种有序的集合，可以随时增加或删除其中的元素。标识是中括号[]。
元组tuple：⼀种类似列表的数据类型，但是不能被修改。
字典dice：全称为dictionary，使⽤键值对（key-value）作为存储⽅式。标识是⼤括号{}。
布尔值bool：表示真假的数据类型，只有两个值，True和False。
数据的操作
字符串的拼接
初阶⽤法：使⽤ ' + ' 进⾏字符串的拼接
进阶⽤法：使⽤ ' % ' 进⾏字符串的拼接
四则运算
运算优先级：
与平时运算优先级⼀样：从左到右顺着来，括号⾥的优先算，乘除排在加减前。
>>>print('风变'+'编程') 1
风变编程 2
3
>>>name = '酱酱' 4
>>>begin = '我叫' 5
>>>print(begin + name) 6
我叫酱酱 7
>>>name = '《凤求凰》' 1
>>>number = 1 2
>>>print('司马相如以%d曲%s打动了卓文君' %(number,name)) 3
司马相如以1曲《凤求凰》打动了卓文君 4
运算符 表示 例⼦
+ 加 1 + 1 输出结果为2
- 减 1 - 1 输出结果为0
* 乘 3 * 2 输出结果为6
/ 除 2 / 1 输出结果为2
% 取模-返回除法的余数 5 % 2 输出结果为1
** 幂-返回x的y次幂 2 ** 3 输出结果为8
// 取整除-返回商的整数部分 11 // 2 输出结果为5
数据转换
type()
#查看变量的数据类型
str()
#将其他数据类型强制转换为字符串
int()
#将整数形式的字符串转化为整数（⽂本类字符串和浮点形式的字符串不能转化为整数）
#对浮点数直接抹零取整
float()
#将整数和字符串转换为浮点数(⽂字类字符串⽆法转换）
list()
#将数据转换为列表类型
len()
#⽤于检查某个数据的⻓度
>>>who = 'xiaojiangjiang' 1
>>>print(type(who)) 2
<class 'str'> 3
4
#结果显示这是一个字符串类型的数据 5
>>>begin = '我吃了' 1
>>>number = 1 2
>>>fruit = '个水果' 3
>>>print(begin + str(number) +fruit) 4
我吃了1个水果 5
6
#进行字符串拼接时，不同数据类型不能直接使用'+'连接，需要现将整数转化为字符串类型 7
>>>print(int(3.8)) 1
3 2
>>>print(float(8)) 1
8.0 2
>>>a = 'python小课' 1
>>>print(list(a)) 2
['p', 'y', 't', 'h', 'o', 'n', '小', '课'] 3
>>>bros = ['刘备','关羽','张飞'] 1
>>>print(len(bros)) 2
3 3
>>>emotion = 'happy' 4
数据的常⽤语法
列表语法
列表的操作可分为两种类型，⼀种类型为对列表元素的处理，另⼀种类型为对列表的处理，每
种类型都有四种操作：提取，修改，增加，删除（取改增删）。
偏移量：对列表元素的位置编号。
#列表的偏移量从0开始计算
#如果要提取⼀段列表，需要使⽤切⽚的形式[a:b]：从a到b的元素，但不包括b（a <= X <
b）；冒号某侧如果没有数字，则全取
列表元素的提取
列表元素的修改
列表元素的增加
append()
#是列表的⽅法，在括号内添加⼀个元素，可以将该元素添加到列表末尾
>>>print(len(emotion)) 5
5 6
>>>list = ['松','竹','梅'] 1
>>>print(list[0]) 2
>>>print(list[1:2]) 3
>>>print(list[:2]) 4
松 5
['竹'] 6
['松','竹'] 7
#松，竹，梅三者的偏移量分辨是0，1，2。 8
>>>list = ['松','竹','梅'] 1
>>>print(list[0]) 2
松 3
4
>>>list = [['松','松树'],['竹','竹子'],['梅','梅花']] 5
>>>print(list[0][1]) 6
松树 7
#嵌套列表的提取 8
>>>list = ['松','竹','梅'] 1
>>>list[0] = '松树' 2
>>>print(list) 3
['松树', '竹', '梅'] 4
>>>list = ['松','竹'] 1
>>>list.append('梅') 2
>>>print(list) 3
易错⼀：⽤append时不能对列表赋值
易错⼆：append后⾯是⼩括号，⽽⾮中括号
易错三：append不能⼀次添加多个元素
列表元素的删除
del
#删除命令
易错⼀：每次只能删除⼀个元素，
易错⼆：删除多个元素时，要重新计算偏移量
列表的切⽚（即列表层⾯的提取，⼀次提取若⼲个元素）
列表的修改
#同样是使⽤赋值语句，注意是对列表的赋值
['松','竹','梅'] 4
>>>list = ['松','竹'] 1
>>>list = list.append('梅') 2
>>>print(list) 3
None 4
#第二行语法错误 5
>>>list = ['松','竹'] 1
>>>list.append['梅'] 2
>>>print(list) 3
TypeError: 'builtin_function_or_method' object is not subscriptable 4
#第二行语法错误 5
>>>list = ['松','竹'] 1
>>>list.append('梅','岁寒三友') 2
>>>print(list) 3
TypeError: append() takes exactly one argument (2 given) 4
#第二行语法错误 5
>>>list = ['松','竹','梅'] 1
>>>del list[0] 2
>>>print(list) 3
>>>del list[0] 4
>>>print(list) 5
['竹', '梅'] 6
['梅'] 7
>>>list = ['松','竹','梅'] 1
>>>print(list[1:2]) 2
>>>print(list[:2]) 3
['竹'] 4
['松','竹'] 5
#注意:列表的切片提取出来的是列表 6
>>>list = ['松','竹','梅'] 1
列表的增加
列表的增加叫作列表的合并会更合理
#使⽤符号'+'
#符号'+'只能⽤在列表之间，不能⽤在列表和元素之间
列表的删除
del
#删除命令
字典语法
字典数据的提取
#列表使⽤偏移量来提取，字典使⽤键来提取
字典数据的修改
>>>list[:] = ['岁寒三友'] 2
#list[:]表示将列表的所有元素取出来 3
>>>print(list) 4
['岁寒三友'] 5
6
#注意以下的错误做法： 7
>>>list = ['松','竹','梅'] 8
>>>list[:] = '岁寒三友' 9
>>>print(list) 10
['岁', '寒', '三', '友'] 11
>>>list1 = ['松'] 1
>>>list2 = ['竹'] 2
>>>list3 = ['梅'] 3
>>>list = list1 + list2 +list3 4
>>>print(list) 5
['松', '竹', '梅'] 6
>>>list = ['松','竹','梅'] 1
>>>del list[:2] 2
>>>print(list) 3
['梅'] 4
>>>group = {'师父':'唐三藏', '大师兄':'孙行者', '二师兄':'猪八戒', '沙师弟':'沙
和尚'}
1
>>>print(group['师父']) 2
唐三藏 3
>>>group = {'师父':'唐三藏', '大师兄':'孙行者', '二师兄':'猪八戒', '沙师弟':'沙
和尚'}
1
>>>group['师父']='唐玄奘' 2
>>>print(group) 3
{'师父': '唐玄奘', '大师兄': '孙行者', '二师兄': '猪八戒', '沙师弟': '沙和尚'} 4
字典数据的增加
字典数据的删除
dict.keys()
#提取字典中所有的键
dict.values()
#提取字典中所有的值
dict.items()
#提取字典中所有的键值对
>>>group = {'师父':'唐三藏', '大师兄':'孙行者', '二师兄':'猪八戒', '沙师弟':'沙
和尚'}
1
>>>group['白龙马']='敖烈' 2
>>>print(group) 3
{'师父': '唐三藏', '大师兄': '孙行者', '二师兄': '猪八戒', '沙师弟': '沙和尚',
'白龙马': '敖烈'}
4
>>>group = {'师父':'唐三藏', '大师兄':'孙行者', '二师兄':'猪八戒', '沙师弟':'沙
和尚'}
1
>>>del group['师父'] 2
>>>print(group) 3
{'大师兄': '孙行者', '二师兄': '猪八戒', '沙师弟': '沙和尚'} 4
>>>group = {'师父':'唐三藏', '大师兄':'孙行者', '二师兄':'猪八戒', '沙师弟':'沙
和尚'}
1
>>>print(group.keys()) 2
dict_keys(['师父', '大师兄', '二师兄', '沙师弟']) 3
4
#打印出了所有字典的键，但是都是元组的形式 5
6
>>>group = {'师父':'唐三藏', '大师兄':'孙行者', '二师兄':'猪八戒', '沙师弟':'沙
和尚'}
7
>>>print(list(group.keys())) 8
['师父', '大师兄', '二师兄', '沙师弟'] 9
10
#通过list()函数将元组转化为列表的形式 11
>>>group = {'师父':'唐三藏', '大师兄':'孙行者', '二师兄':'猪八戒', '沙师弟':'沙
和尚'}
1
>>>print(group.values()) 2
dict_values(['唐三藏', '孙行者', '猪八戒', '沙和尚']) 3
>>>group = {'师父':'唐三藏', '大师兄':'孙行者', '二师兄':'猪八戒', '沙师弟':'沙
和尚'}
1
>>>print(group.items()) 2
产⽣布尔值的表达式
bool()
#检查数值的真假
值本身作为条件
⽐较运算符产⽣布尔值
成员运算符产⽣布尔值
逻辑运算符产⽣布尔值
dict_items([('师父', '唐三藏'), ('大师兄', '孙行者'), ('二师兄', '猪八戒'),
('沙师弟', '沙和尚')])
3
>>>print(bool(1)) 1
True 2
假的 其他都是真的
False True
0 5（任意整数）1.0（任意浮点数）
''（空字符串） '⻛变编程'（字符串）
[]（空列表） [1,2,3]
{}（空字典） {1:'a',2:'b'}
None
运算符 释义 作⽤
== 等于 如果两侧的值相等，条件为真
!= 不等于 如果两侧的值不相等，条件为真
> ⼤于 如果左侧的值⼤于右侧，条件为真
< ⼩于 如果左侧的值⼤于右侧，条件为真
>= ⼤于等于 如果左侧的值⼤于或等于右侧，条件为真
<= ⼩于等于 如果左侧的值⼩于或等于右侧，条件为真
注意：运算符之间不⽤空格，不可以写成= =、> =
运算符 释义 作⽤
in 属于 如果值在指定序列⾥，条件为真
not in 不属于 如果值不在指定序列⾥，条件为真
运算符 释义 作⽤
and 且 连接两个布尔值，如果两个都为真，该条件才为真
三、循环
for循环
for循环的基本格式是：for…in…
for…in dict:
#遍历字典的键
for…in dict.values():
#遍历字典的值
for…in dict.items():
#遍历字典的键值对
or 或 连接两个布尔值，如果有⼀个为真，该条件即为真
not ⾮ 反逻辑状态，a为True，not a则为False，反之亦然
#遍历字符串 1
>>>for i in 'coding': 2
... print(i) 3
c 4
o 5
d 6
i 7
n 8
g 9
10
#遍历列表 11
>>>for i in ['for','change'] 12
... print(i) 13
for 14
change 15
>>>list = {1:'a',2:'b',3:'c'} 1
>>>for i in list: 2
...    print(i) 3
1 4
2 5
3 6
>>>list = {1:'a',2:'b',3:'c'} 1
>>>for i in list.values(): 2
...    print(i) 3
a 4
b 5
c 6
range()函数
#range()有最基本的三种⽤法：range(b)， range(a,b)，range(a,b,c)。
#函数中各个数值的意义：a：计数从a开始。不填时，从0开始；b：计数到b结束，但不包括
b；c：计数的间隔，不填时默认为1。
for…in range()
#处理指定次数的循环
while循环
while循环
#当条件为真时，执⾏循环语句，只要条件为真，便会⼀直循环
while循环和for循环的区别：
#for擅⻓处理固定次，⾃动遍历各序列
#while处理不定次数的循环，条件为False便停⽌
>>>list = {1:'a',2:'b',3:'c'} 1
>>>for k, v in list.items(): 2
...    print(k) 3
...    print(v) 4
1 5
a 6
2 7
b 8
3 9
c 10
>>>range(5) 1
#计数依次为0，1，2，3，4 2
3
>>>range(1,5) 4
#计数依次为1，2，3，4 5
6
>>>range(2,8,2) 7
#计数依次为2，4，6 8
>>>for i in range(3): 1
... print('第%d遍风变编程' %i) 2
第0遍风变编程 3
第1遍风变编程 4
第2遍风变编程 5
>>>count = 3 1
>>>while count > 1: 2
...    print('happy coding') 3
...    count = count -1 4
happy coding 5
happy coding 6
循环进阶
break
#如果满⾜条件，则结束循环
continue
#如果满⾜条件，则跳过当前循环的剩余语句，直接开始下⼀轮循环
else
#⽆论是否进⼊循环，最后都会执⾏esle语句，除⾮执⾏break语句跳出循环
>>>while True: 1
...    print('happy coding') 2
...    break 3
happy coding 4
5
#break会结束循环，如果只有前两行代码，会无限循环打印happy coding 6
7
>>>count = 3 8
>>>while count >1: 9
...    print('happy coding') 10
...    count = count - 1 11
...    if count == 2: #当count等于2的时候，停止循环 12
...        break 13
happy coding 14
15
#对比while循环的例子，我们发现这里只打印了一次happy coding 16
count = 3 1
while count >1: 2
    print('happy') 3
    count = count - 1 4
    if count == 2: #当count等于2的时候，跳过下列语句，重新开始新的一轮循环 5
        continue 6
    print('coding') #由于continue语句，coding只会打印一次 7
8
#打印的结果为： 9
happy 10
happy 11
coding 12
count = 3 1
while count >2: 2
    print('在风变') 3
    count = count -1 4
else: #无论是否进入循环都会执行else语句 5
    print('happy coding') 6
7
#打印结果为： 8
在风变 9
循环嵌套
#即循环中有循环
四、函数
函数基本知识
函数
函数是组织好的、可以重复使⽤的、⽤来实现单⼀功能的代码
函数类型可分为⾃定义函数和内置函数，⾃定义函数是需要⾃⼰定义，⽽内置函数是python
内部已经定义好的函数，⽐如print()、input()等
函数定义的语法
def
#定义函数
return
#函数的返回值
#函数定义的格式
#⼀个简单的例⼦
变量作⽤域
happy coding 10
>>>for i in ['风变','编程']: #首先遍历列表元素 1
...    for t in i: #然后遍历元素(字符串) 2
...        print(t) 3
风 4
变 5
编 6
程 7
def 函数名(参数)： 1
函数体 2
return 语句 3
def math_func(x): 1
    y = x + 5 2
    print(y) 3
    return y 4
math_func(2) 5
6
#打印结果为7 7
变量作⽤域可认为是变量作⽤的范围
全局变量：在全局内⽣效的变量
局部变量：只能函数内或者⼀定代码块内⽣效
global
#将局部变量转化为局部变量
python内置函数
#点击函数即可进⼊python官⽅⽂档查看其功能
五、类与对象
概念
类：具有相同属性和⽅法的对象的抽象
实例：类的个例
对象：Python中的对象是类和实例的集合，类可以看作是对象，实例也可以看作是对象
基本语法
class
#定义类，注意类名需要⼤写
内置函数
abs() delattr() hash() memoryview() set()
all() dict() help() min() setattr()
any() dir() hex() next() slice()
ascii() divmod() id() object() sorted()
bin() enumerate() input() oct() staticmethod()
bool() eval() int() open() str()
breakpoint() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()
class A(B)
#定义B类的⼦类A类，A类具有B类的属性和⽅法，也将B类称为A类的⽗类
class A(B, C)
#多重继承，A类同时是B类和C类的⼦类，A类在调⽤属性和⽅法的时候，会优先调⽤位于左
侧的类
def __init__(self):
#创建类的初始化⽅法，只要调⽤类，便⾃动调⽤初始化⽅法的语句，常⽤于创建实例属性
class MyClass: #定义类MyClass 1
    i =12345  #定义类的属性(变量) 2
    def f(self): #定义类的方法 3
        return('hello world') #执行这个方法会返回'hello word'这个字符串 4
x = MyClass() #创建类的实例x 5
print(x.i) #打印实例x的属性 6
print(x.f()) #打印实例x的f方法 7
8
#输出的结果为 9
12345 10
hello world 11
class SecondClass(MyClass): 1
    pass    2
#定义SecondClass是MyClass的子类，SecondClass可以调用MyClass的属性和方法 3
x = SecondClass() 4
print(x.i) 5
print(x.f()) 6
7
#输出的结果为 8
12345 9
hello world 10
class B: 1
i = 123 #B类的属性是i=123 2
class C: 3
i = 12345 #C类的属性是i=12345 4
class A(B,C): #A类是B类和C类的子类 5
pass 6
x = A() #创建A类的实例x 7
print(x.i) #调用属性,会优先调用B类的属性 8
9
#结果输出为 10
123 11
>>>class A: 1
...    def __init__(self): #只要创建实例，便会自动执行初始化方法下的语句 2
...        print('hello world') 3
>>>x = A() 4
hello world #只要创建实例就会调用方法,打印hello world 5
super()
#在⼦类的⽅法⾥调⽤⽗类的⽅法，使⼦类的⽅法可以在继承⽗类⽅法的基础上进⾏扩展
六、模块与库
模块类型
内置模块
#python官⽅组织编写和维护的模块
⾃定义模块
#⾃⼰写代码，然后将代码块保存为 .py ⽂件
第三⽅模块
#从⾃定义模块⽽来，代码写作者公开⾃⼰的代码
#根据模块的组织形式的不同，也可分为单个模块⽂件、模块包、模块库
模块和模块对象导⼊⽅法
import A
#导⼊模块A
#现在可以调⽤模块⾥函数和变量，但是必须通过【模块名.函数名()】和【模块名.变量名】的
⽅式调⽤
#创建类实例的时候，需要使⽤【实例名 = 模块名.类名()】进⾏创建，创建实例后调⽤类⽅法
和属性可以使⽤【实例名.函数名()】和【实例名.变量名】
import A as a
#导⼊模块A，并将模块A重新命名为a
#调⽤模块中的类、函数和变量如上述操作⼀样
from A import B
#导⼊模块A中的对象B
#调⽤对象B中的函数和变量可以不加模块名
from A import B，C，D
#导⼊模块A中的多个对象B，C，D
6
#对比以下没有初始化的方法： 7
8
>>>class A: 9
...    def f(self): 10
...        print('hello world') 11
>>>x = A() 12
13
#不使用初始化方法，创建实例无任何输出 14
from A import *
#导⼊模块A中的所有对象
if __name__=="__main__":
# 当.py文件被直接运行时， if __name__=="__main__": 之下的代码块将被运行
#当.py文件以模块形式被导入时， if __name__=="__main__": 之下的代码块不被运行
七、⽂件读写
⽂件读写三步骤
第⼀步，打开⽂件
第⼆步，读（写）⽂件
第三步，关闭⽂件
打开⽂件语法
open(file, mode, encoding)
#打开⽂件
with open() as…
#使⽤这种⽅式打开⽂件，可以不使⽤close()关闭⽂件
读写模式mode
f = open('/letter.txt', 'r', encoding = 'UTF-8') 1
with open('/letter.txt', 'r', encoding = 'UTF-8') as f: 1
模式mode 操作 若不存在 是否覆盖
r 只能读不能写 报错 -
rb ⼆进制只读 报错 -
r+ 可读可写 报错 是
rb+ ⼆进制读写 报错 是
w 只能写不能读 创建⽂件 是
wb ⼆进制只写 创建⽂件 是
w+ 可读可写 创建⽂件 是
wb+ ⼆进制读写 创建⽂件 是
a 追加不能读 创建⽂件 否，追加写
ab ⼆进制追加不能读 创建⽂件 否，追加写
a+ 可读可写 创建⽂件 否，追加写
ab+ ⼆进制追加可读可写 创建⽂件 否，追加写
读写⽂件语法
read()
#读取⽂件内容
readlines()
#以列表的⽅式读取⽂件内容
write()
#清空⽂件内容，并写⼊字符串⼊内容
writelines()
#清空⽂件内容，以列表的⽅式写⼊
关闭⽂件语法
close()
#关闭⽂件
csv文件读写的相关函数
reader()
#读取csv文件的函数
writer()
#将内容写入csv文件
with open('/letter.txt','r',encoding = 'UTF-8') as f: 1
content = f.read() 2
3
#以字符串的形式读取文件内容，将文件内容赋值给变量content 4
with open('/letter.txt','r',encoding = 'UTF-8') as f: 1
content = f.readlines() 2
3
#以列表的形式读取文件内容，将文件内容赋值给变量content 4
with open('/letter.txt','r',encoding = 'UTF-8') as f: 1
f.write('python') 2
with open('/letter.txt','r',encoding = 'UTF-8') as f: 1
f.write('python') 2
import csv #导入csv模块 1
with open('letter.csv') as f: 2
reader = csv.reader(f) #读取csv文件，将文件内容赋值到reader 3
writerow()
#写入一行内容
writerows()
#一次写入多行csv文件
os模块
os.getcwd()
#返回当前的⼯作⽬录
⼋、debug
try…except…语句
⽤于处理
九、其他
str.spilt()
#返回⼀个由字符串内单词组成的列表
random模块
#随机模块
import csv #导入csv模块 1
with open('letter.csv','w',newline = '') as f: 2
writer = csv.writer(f) #写入csv文件 3
writer.writerow(['python小课'，'风变编程']) #写入一行内容 4
data = [['交互式学习'，'更简单'],['助教酱酱','为你答疑解惑']] 5
writer.writerows(data) #写入多行内容 6
for i in range(6): 1
try: 2
print(6/i) 3
#使用6依次除于0，1，2，3，4，5，并打印 4
except ZeroDivisionError 5
#除非发生ZeroDivisionError类型的错误，执行下列语句 6
print('0是不能做除数的！') 7
>>>'1,2,3'.split() 1
['1',',','2',',','3'] 2
>>>'1,2,3'.split('?,') 3
['1','2','3'] 4
import random 1
#需要先导入random模块，然后再调用相应方法 2
3
转义字符
print(random.randint(1,10)) # 产生 1 到 10 的一个整数型随机数 4
print(random.random()) # 产生 0 到 1 之间的随机浮点数 5
print(random.uniform(1.1,5.4)) # 产生 1.1 到 5.4 之间的随机浮点数，区间可
以不是整数
6
print(random.choice('tomorrow')) # 从序列中随机选取一个元素 7
print(random.randrange(1,100,2)) # 生成从1到100的间隔为2的随机整数 8
转义字符 意义
\a 响铃(BEL)
\b 退格(BS)，将当前位置移到前⼀列
\f 换⻚(FF)，将当前位置移到下⻚开头
\n 换⾏(LF)，将当前位置移到下⼀⾏开头
\r 回⻋(CR)，将当前位置移到本⾏开头
\t ⽔平制表(HT) (跳到下⼀个TAB位置)
\v 垂直制表(VT)
\\ 代表⼀个反斜杠字符"\"
\' 代表⼀个单引号(撇号)字符
\" 代表⼀个双引号字符
\? 代表⼀个问号
\0 空字符(NUL)
\ddd 1到3位⼋进制所代表的任意字符
\xhh 1到2位⼗六进制所代表的任意字符
注意1：区分斜杠“/”和反斜杠“\”，此处不可互换。
注意2：以上表格内容也不需要硬记。
 

好啦，我就分享到这里，感谢您能看到这里