基础知识

计算机字节级别;
1kb = 1024字节
1Mb = 1024Kb
1G = 1024Mb
1T = 1024G

2、计算机的组成
硬件运算器控制器存储器输入设备输出设备
软件系统软件 xp win 10
应用软件 qq 微信
编程语言
人与计算机进行交流的语言
c python java c++ php go

3、python的发展史优缺点和就业方向
诞生的时间 1991
作者龟叔
优缺点
优点简单易学免费开源
高层语言可移植性强
解释性语言面向对象
可扩展性丰富的库规范的代码
缺点执行效率慢

就业方向
1、web开发 — 美多商城实验楼
2、运维工程师 — 维护服务器通过python写脚本
3、爬虫工程师 ---- 爬取数据数据分析
4、游戏开发 AI识别桌面软件

4、第一个python程序
输出 helloworld
注意在python里双(单)引号里不能套双(单)引号必须都是英文的
双(单)引号里能套单(双)引号

5、注释
单行注释一个 #
快速注释 ctrl + /
多行注释 ‘’’ ‘’’
作用对代码进行解释说明
注意注释的代码或者文字不会被运行
python代码是从上往下一行一行运行的

变量
用来存储数据
一个=是赋值
两个==是等于
num=10

类型
str（字符串）举例：“4” ‘刘振赫’
list（列表）举例：[1,2 ‘刘振赫’，{“name”：‘薛飞’}]，增删改查
dict（字典）举例：{“name”:‘薛飞’}，以键值对存在的
set（集合）举例{1,2,3，4}
tuple（元祖）举例：（1,2,3,4）
布尔类型举例：Ture，False
int代表整数
float代表浮点数
type（）检测数据变量类型

1.标识符和关键字
生活中的标识符？
KTV 网吧酒吧宾馆红绿灯斑马线
作用：
1.提示 2.见名思意
代码中的标识符？
变量名，函数名，类名
定义：开发人员在程序中定义的名字和符号
命名规则：1.由字母数字下划线组成
2.不能以数字开头
3.不能使用关键字，如何查看python中的关键字？
A.导包import keyword B.使用keyword，kwlist C、输出
举例：import keyword-------print（keyword，kwlist）
[‘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’]
命名方法：
ZhangHao--------每一个单词的首字母大写大驼峰命名法
zhangHaoHao--------第一个首字母小写，剩下的首字母大写小驼峰命名法
zhang_hao_hao--------每一个单词后面连接下划线下划线命名法

2.输入输出
输入
input（）输入的数据类型-----------一定/必须/肯定/是字符串（str）
输出
print（）
格式化输出：
print（“%”%变量名）---------------%d代表int整数---------%f代表float小数，默认是6位！.2f两位 .3f三位以此类推
%s代表字符串

3.运算符
算数运算符：+ - * / %(取余数) //（取整数） **（指数）
赋值运算符：=（就是赋值的意思）例如：num=10，把等号右边的内容赋值给了num
复合运算符：+= -= *= /= //= %= **=

4.数据类型之间的转换
int（）------整形
float()--------浮点型
tuple()-------元祖
set()---------集合
list()----------列表
chr() 将数字转换成字母 A-Z 用ASCII转换对应的数字65-90
ord（）将字母转换成数字 a-z用ASCII转换对应的数字97-122

判断语句
当条件成立的时候--------执行代码
当条件不成立的时候---------执行另一个代码
if 变量名关系运算符条件成立：
输出
else：条件不成立
输出
当有多个条件的时候使用elif
else可以和if搭配也可以和for/while搭配
elif只能和if一起使用
while 1：/ while True：死循环 ----------当条件成立是一直循环，True代表真
break输入错误时结束，退出循环

如何使用python输入随机数
1.导包import random
2.使用random模块里的randint函数
3.输入随机数的范围
举例：import random
print（random.randint(1,100)）
简便方法：print(random.randint(1,100))
import 用来导包的，在random后面按住alt + enter

1.关系运算符
< > <= >= ==（判断两个变量的值是否相等） !=
2.逻辑运算符
and 当所有条件同时满足的时候
or 满足其中任何一个条件就可以
not 取反，对就是错，错就是对
3.if嵌套
简单理解就是if里面套if
举例1.安检是否携带易燃易爆物品，或危险物品
2.检票判断是否有票
4.while和for循环九九乘法表/水仙花数
while循环格式：初始值，循环条件，循环语句，步长
举例：
num=9 定义变量，给初始值
while<=1: 循环条件
print(“我真帅”) 循环语句
num-=1 步长值
while嵌套:
while里面有while
列的while
行的while

for
语法
for + 临时变量名 + in + 字符串/元祖/字典/集合/range()等等数据类型：
print（“临时变量名”）

在循环数字的时候需要用到range（）函数
------for i in range（1,9） 1<=i <9 包头不包尾
如果起始值<终止值步长值为正默认是1 可以不写
如果起始值> 终止值步长值为负步长值必须写
break 立即终止循环
continue 结束本次循环，继续下个循环
pass 占位符
if（“7” in str(i) or (i%7==0））判断7的倍数和含7的数字
IndentationError: expected an indented block--------提示出现这个，说明格式一定有错误

字符串 str
用’’ or"" 引起来的数据

1.索引/下标
通过下标可以找到像对应的元素
第一个元素的下标是0 最后一个元素的下标是-1
通过元素找到字符串里元素的下标
用find（）查找元素在字符串里的下标

2.切片
包头不包尾
[起始值:终止值:步长值]
起始值<终止值步长值为正默认1 可以不写
起始值>终止值步长值为负默认-1 步长值必须写
[:] 正着输出全部
[:：-1] 倒着呃输出全部

3.字符串的拼接
1.同一个数据类型 ------直接使用+
2.当数字类型和字符串类型相加是需要把数字类型用str()转换成字符串类型
需求用字符串拼接输出我今天走了12345步
例子：
str1=“我今天走了”
str2=12345
str3=“步”
print(str1+str(str2)+str3)

4.计算字符串的长度 len（）----例子：print（len（变量名））
不计为重点#首先要了解一个字符所占的字节数
#在python中数字英文小数点下划线空格占一个字节
#汉字占3个字符
#python的编码方式 utf-8
#计算机的编码方式 GBK
例子：print(len(变量名.encode()))

5.字符串的分割
1.（分割 split() 就是把字符串分割成列表
split（self，sep，maxsplit）
sep 代表你想用什么去分默认是None 即空格 /t
maxsplit 可选参数
2.合并/拼接
join(）

6.count 统计某个元素在字符串里出现的次数--------print（变量名.count（“”））
7.index 用来查找某个元素的下标如果没有该元素，会报错
8.find 用来查找某个元素的下标如果没有该元素，返回-1
9.endswith（）判断字符串是否以xx结尾
10.startswith（）判断字符串是否以xx开头
11.upper（）将字符串中所有的小写字母转换成大写字母
12.lower（）将字符串中所有的大写字母转换成小写字母-
13.title（）将字符串中所有的单词首字母大写
14.capitalize（）将字符串中第一个单词的首字母大写
15.strip（）去除字符串两边的空格
16.lstrip（）去除字符串左边的空格
17.rstrip（）去除字符串右边的空格
18.replace（“旧值”，“新值”，3）替换（旧值，新值），3代表替换3个
19.isdigit（）判断字符串是否都是数字
19.islower（）判断字符串中的字母是否是小写
20.isupper（）判断字符串中的字母是否是大写
21.isalpha（）判断字符串中的元素是否都是字母
22.isalnum（）判断字符串中的元素是否都是字母，或者数字，或者字母加数字
23.isspace（数字）判断字符串中的元素是否都是空格
24.center（）把字符串里面的元素居中
25.rfind（）从字符串的右边往左查找下标

列表的定义：
1.是由一系列按照特定顺序排列元素组成的
2.把元素放在一个[]，每两个相邻的以，隔开
3.里面的元素可以是数字，str，dict，set，list，tuple、等任何的数据类型

列表的创建：
1.以赋值的方式 =
2.可以创建空列表
3.可以创建数值列表使用list（）举例：
list2=list(range(1,10))
print(list2)
4.删除列表 del+列表名举例：
list_1=[1,“we”,(1,2,3),{1,2,3,},[1,2,5]]
del list_1
print(list_1)

5.循环列表用for 举例：
list_1=[1,“we”,(1,2,3),{1,2,3,},[1,2,5]]
for i in list_1:
print(i)

【列表中的其他方法】
1.count 同级元素在列表中出现的次数
2.index 查找元素的下标
3.sum 求列表中的数字和，只有列表中全是数字的时候，才能使用，不然报错
4.sort 排序-------列表中的元素必须全部是数字类型，或者全部都是字母，
如果是字母和数字混合的话会报错。
格式：1.列表名.sort（reverse=False）什么都不写默认时升序，从小到大 reverse=False
2.列表名.sort（reverse=True）降序，从大到小
5.列表的嵌套 ---- 列表里放列表
----掌握在列表的嵌套里找到相对应的元素并修改
列表生成式
举例：lis = [2,3,‘k’,[‘qwe’,20,[‘k’,[‘tt’,3,‘1’]],89],‘ab’,‘adv’] # 写一个函数将该列表中的tt变成大写
lis[3][2][1][0]=“TT”
print(lis)

8.列表的操作
【增】 1.append（）默认在列表的末尾添加
格式：列表名.append(“要添加的元素”)
举例：list_2=[“迪丽热巴”,“李树萍”]
list_2.append(“linmu”)
print(list_2)

2.insert（）根据下标添加元素
格式：列表名.insert（指定位置的下标，“要添加的元素”）
举例：list_2=[“迪丽热巴”,“李树萍”]
list_2.insert(1,“子”)
print(list_2)

3.extend（）将序列中的元素琢一添加到另一个列表中
格式：列表名.extend(列表名)
举例：list_2=[“迪丽热巴”,“李树萍”]
nub_1={1,2,3}
list_2.extend(nub_1)
print(list_2)

【改】根据下标修改元素
格式：列表名[]=新值
举例：list_2=[“迪丽热巴”,“李树萍”]
list_2[1]=“林木”
print(list_2)

【删】
1.del 根据下标删除相对应的元素
格式：del 加变量名加[数字]
举例：list_2=[“迪丽热巴”,“李树萍”,“林木”,“范冰冰”]
del list_2[1]
print(list_2)

2.clear（）清空列表
格式：列表名.clear()
举例：list_2=[“迪丽热巴”,“李树萍”,“林木”,“范冰冰”]
list_2.clear()
print(list_2)

3.remove（）根据元素删除列表内容
格式：列表名.remove(元素名)
举例：list_2=[“迪丽热巴”,“李树萍”,“林木”,“范冰冰”]
list_2.remove(“李树萍”)
print(list_2)

【查】
1.会输出列表中的元素和元素对应的下标用enumerate，举例：
list_1=[1,“we”,(1,2,3),{1,2,3,},[1,2,5]]
for i,x in enumerate(list_1):
print(x,i)

2.访问列表元素用下标举例：
list_1=[1,“we”,(1,2,3),{1,2,3,},[1,2,5]]
print(list_1[2:])

3.index 查找元素在列表中的下标
4.sum 求列表中的数字和，只有列表中全是数字的时候，才能使用，不然报错

9.列表生成式/推导式
作用----------快速生成列表的
格式：[表达式数值列表] 没有标点符号的
[临时变量根据要求生成列表]
举例1：list1=[i for i in range(0,10,2)]
print(list1)
举例2：list2=[random.randint(10,100) for i in range(10)]
print(sum(list2))

字符串中求数字和：
list_5=[]
str1=“ge1wg2ew3g5e4wi6”
for i in str1:
if i.isdigit():
list_5.append(int(i))
print(sum(list_5))

字符串中判断哪个元素出现的次数最多：
a = “aAsmr3iddA4bgs7Dlsf9eAF”
aa = 0 # 存放当前字母出现的次数，最大的
bb = 0 # 存放当前出现次数最多的字母
for i in a:
if a.count(i) > aa:
aa = a.count(i)
bb = i
print(bb)

元祖
【定义】
1.存放的都是按照特定顺序排列的元素
2.每个元素之间用，隔开
3.用（）表示
4.元祖和列表里都可以存放数据类型
5.元祖是不可变的，和列表不同的是，列表里的元素可以修改，元组里的元素不可以修改。
6.列表和元祖之间可以互相转换
【创建】

= 使用赋值运算符直接创建
空元组（）
创建数值元祖 tuple（range（））
【删除】
del+元组名
将元祖删除
【增】----------No
【删】----------No
【改】----------No
【查】
下标，切片，还能循环遍历元祖
【元祖推导式】--------会生成一个生成器---------查看生成器，用list强转查看
举例：tuple22=(i for i in range(1,10))
print(list(tuple22))
【其他方法】
index 获取下标的
count 查找元祖在元祖中出现的次数
sum 求和

字典
定义：1.以一组键值对存在的数据的序列
举例：dcit_1={“name”:“徐飞”,“age”:“18”}
name叫做字典的key（键），“徐飞”叫做字典的value（值）
2.{} 中间的键值对以，隔开
【字典的特征】
1.想获取字典的值，是通过键来获取
2.字典是无序的------没有下标
3.字典是可变的----------增，删，改，查
4.字典的键是唯一的如果一个键出现多次会输出最后一个值
举例：dcit_1={“name”:“徐飞”,“age”:“18”,“name”:“林木”}
print(dcit_1[“name”]) #如果name出现多次默认为结尾的值输出
5.字典的键必须是不可变的数据类型---------数字，字符串，元祖
【创建】
1.= 以赋值的方式
2.空列表 {}
3.需要一个映射函数来创建 zip（）
格式：变量名=dict（zip（里面放列表1，列表2））
举例：list1=[“name”,“age”,“sex”] #一个列表
list2=[“林木”,17,“男”] #一个列表
dict33=dict(zip(list1,list2)) #把两个列表依次放入字典的键和值，如果某个列表元素少了，那值和列表都不输出
print(dict33)
4.可以根据指定的键值对创建
举例：print(dict(name=“林木”,age=18,sex=“男”))
5.将一个空列表添加值和键，等号相当于：号
举例：dict3={}
dict3[“name”,]=“李树萍,林木”
print(dict3)

【增】
格式：1.通过字典名[“新建名”]=新值
举例:dict111={“name”:“李树萍”,“age”:“18”}
dict111[“sex”]=“女” #当字典里的key没有时会添加到末尾
print(dict111)
2.字典名.update（字典名1）-----如果要合并的字典和原字典的键名相同，那么字典里的值以要合并的字典的值为准
举例：dict111={“name”:“李树萍”,“age”:“18”}
dict444={“name1”:“李树萍”,“age1”:“18”}
dict111.update(dict444)
print(dict111)
【改】
格式：字典名[“新名”]=新值
举例：dict111={“name”:“李树萍”,“age”:“18”}
dict111[“name”]=“林木” #当字典的key有的话就是更改key的值
print(dict111)
【删】
1.del 字典名[“键名”]
举例：dict111={“name”:“李树萍”,“age”:“18”}
del dict111[“age”] #del 加字典名加key就是把字典的键删了
print(dict111)
2.celar（）清空列表
举例：dict111={“name”:“李树萍”,“age”:“18”}
dict111.clear()
print(dict111)
3.字典名.pop[键名] 根据字典的键名删除值
举例：# dict111={“name”:“李树萍”,“age”:“18”}

dict111.pop(“age”)

print(dict111)

【查】
格式：字典名.get（“键名”，默认值）-------当查的键名不存在的时候，会返回这个键名
举例：dcit_1={“name”:“徐飞”,“age”:“18”,“name”:“林木”}
print(dcit_1.get(“id”,19)) #查询我字典里面是否有这个key，如果没有输出，19

【字典的循环遍历】
1.格式：字典名.items ---------字典-------返回的是元祖
举例：dict111={“name”:“吴志浩”,“age”:“18”,“sex”:“男”}
for i in dict111.values(): #循环字典的值
print(i)
2.格式：字典名.keys --------字典的键
举例：dict111={“name”:“吴志浩”,“age”:“18”,“sex”:“男”}
for i in dict111.keys(): #循环字典的键（key）
print(i)
3.格式:字典名.values-------- 字典的值
举例：dict111={“name”:“吴志浩”,“age”:“18”,“sex”:“男”}
for i in dict111.items(): #循环整个字典
print(i)

【其他方法】
sum-------- 要使用sum就必须要确定字典里的键和值必须都是数字
1.要求字典里键的和用 sum(字典名.keys)
举例：ct111={1:2,5:18}
print(sum(dict111.keys())) #keys代表字典里的键
2.要求字典里的值得和用 sum（字典名.values）
举例：dict111={1:2,5:18}
print(sum(dict111.values())) values代表字典的值

集合--------set
【定义】
1.{}
2.中间的元素用，隔开
3.集合里的元素是唯一的---------会自动去掉重复的
4.集合里的元素是无序的
【创建】
1.= 使用赋值运算符创建
2.使用set（）函数创建-----强转
举例：list1=[1,5,7,9,4,6]
set22=set(list1) #将列表强转成集合
print(set22)
3.集合里面的元素不能是集合{}，或者字典或者列表，里面只可以放不可变的数据类型，集合里的元素是不可变类型
4.能不能使用{} 来创建空集合--------不能
5.创建空集合使用set（）
举例：set22=set()
print(set22)
【删除】
del 加集合名
【增】
1.add-----
格式：集合名.add（要添加的元素）--------一次只能添加一个元素
举例：set01={1,9,7}
set01.add(8)
print(set01)
2.update（）-----拼接
格式：集合名.update（要添加的类型）
举例：set01={1,9,7,5,6}
set03=“我是”
set01.update(set03)
print(set01)
【删】
1.集合名.pop（）-----随机删除一个元素
举例：set01={1,9,7,5,6}

set01.pop() #随机删除一个元素

print(set01)

2.集合名.remove(输入元素) -----指定元素删除
举例：set01={1,9,7,5,6}

set01.remove(7) #指定删除一个元素

print(set01)

3.集合名.clear()---------清空集合
举例：set01={1,9,7,5,6}
set01.clear()
print(set01) #清空集合
4.集合名.discard(输入元素)-------和remove不同的是，如果要删除的元素不存在，用remove会报错，
而discard不会报错
【改】---------没有改，因为每一个元素都是唯一的
【查】----------没有查，因为它是无序的，下标不固定
【循环遍历】
举例：set01={1,9,7,5,6}
for i in set01: #循环整个集合，循环时集合里的元素是无序的
print(i)

【其他方法】
sum---------元素必须都是数字类型

【集合的交集和并集】
交集&(与字符)----------共同拥有的元素
举例:set001={“迪丽热巴”,“范冰冰”,“李树萍”,“林木”}
set002={“迪丽热巴”,“子”,“李树萍”,“岳飞”}
set003=set001&set002
print(set003)

并集|（管道符）------把所有的元素放在一起，重复的显示一次
举例:set001={“迪丽热巴”,“范冰冰”,“李树萍”,“林木”}
set002={“迪丽热巴”,“儿子”,“李树萍”,“岳飞”}
set003=set001| set002
print(set003)

【公共方法】
±-----------------拼接----只有字符串，列表，元祖可以使用
*------------------复制-----只有字符串，列表，元祖可以使用
in----------------在--------只有字符串，列表，元祖，字典可以使用
not in---------不在---------只有字符串，列表，元祖，字典可以使用

【内置函数】
1.len 获取数量的长度
举例：list66=[1,5,6,7,20]
print(len(list66))
2.max 获取最大值
举例：list66=[1,5,6,7,20]
print(max(list66))
3.min 获取最小值
举例：举例：list66=[1,5,6,7,20]
print(min(list66))
4.del.变量名删除元素
举例：list66=[1,5,6,7,20]
del list66
print(list66)

函数
1.之前学过很多内置函数，比如sum（） print（） range（）这些函数帮助我们能够
快速处理数据，达到目的
2.我们能不能自己定义一些函数，来帮助我们快速的处理数据------必须可以
3.所谓的自定义函数就是把一段有规律的可重复的代码块定义成函数，达到一次定义，多次调用的目的
4.函数的作用---------提高代码的重复利用率
【创建】
函数名--------------遵循标识符的命名规则，和命名方法
格式:def 函数名（）
函数体，就是代码
函数名（）---------------是调用的意思
需要注意：
1.函数只有在调用的时候才能执行
举例：def fun(): #函数的格式def加函数名（）
print(“我好帅”) #写函数内的代码，函数体
fun() #调用函数
2.函数的大执行步骤：调用函数，才会执行函数中的内容

函数的参数
参数分为形参和实参
形参，就是在函数定义的括号里写的参数
实参，就是在函数调用的括号里写的参数
注意：实参和形参的个数必须是一样的
格式：def 函数名(参数):
函数体
函数名（实参）

【关键字参数】
格式：某一个参数有一个固定值得时候，那么就可以在定义函数的时候给参数一个固定值，
简单说就是给形参一个值，调用的时候就少写一个实参
举例：def func(a,b=3): #b在形参加个值，实参就不用写了
print(a+b)
func(1)
【不定长参数】
当形参中有不定长参数的时候，一定要放到形参的最后，**kwargs在*args之后
1.*args------表示形参接收多个实参的值，并且将其放到一个元祖中
举例：def func(a,*b): #b我们通常用args来表示
print(a+sum(b))
func(1,2,3,4,5,6,7,8,9)

2.**kwargs------表示形参接收多个实参的值，并且将其放到一个字典中，实参一般是name=“吴志浩”，age=17
举例：def func(a,*b,**c): #b我们通常用args来表示,**c接受字典的形式
print(a+sum(b))
print©
func(1,2,3,4,5,6,7,8,9,name=“吴志浩”,age=18)

【返回值】
return----------有return必须有print
作用：1.将返回值返回-------如果return返回的是一个值，那么这个值，可以是任意类型，
如果return返回的是多个值，那么这个值，是元祖类型
举例：# def func(a,b): #定义一个函数名，参数有a和b

c=a+b #把a+b赋值给了c

d=a-b ##把a-b赋值给了d

return c,d 把c和d返回值了，就是没有地方输出

print(func(5,2)) 输出c和d计算的数

       2.结束函数

变量的作用域
【局部变量】-----------作用域只能在，函数内部
举例：def func():
num1=10 #num1只能在func1内使用
print(num1)
func()

【全局变量】-------作用域在全局，函数内外都可以使用
举例：num11=20 #num11可以在全局使用
def func():
num1 = 10
print(num1+num11) # num1只能在func1使用
func()
print(num11)、

函数内部是否能修改全局变量------ok
在函数内部使用global加变量名，然后重新再内部赋值，修改全局变量
举例：num11=20 #num11可以在全局使用
def func():
num1 = 10
global num11 #修改num11的值
num11=10 #修改成10
print(num1+num11) # num1只能在func1使用
func()
print(num11)

函数的类型--------------参数和返回值的数量来区分的·
1.无参数，无返回值
举例：def func():
num1=10
print(num1) #num1只能在func1使用
func()
2.无参数，有返回值
def func():
nub11=10
return nub11
print(func())
3.有参数，无返回值
举例：def func():
nub11=10
nub22=20
print(nub11+nub22)
func()
4.有参数，有返回值
举例：def func(a,b):
return a+b
print(func(2,8))

函数的嵌套---------理解函数嵌套的执行流程
两个函数分别是：一个是内部函数，一个是外部函数
举例：def func():
print(“我是谁”)
print(“我在哪”)
print(“我好帅”)

def func1():
print(“我是谁11”)
func()
print(“我是谁22”)
print(“我是谁33”)
func1() #因为func没有调用，但是func1里面调用
#了func，所以会按顺序执行

匿名函数
匿名？-------没有名字
没有名字的函数
【语法】
格式：lambda 参数列表：表达式
举例：#匿名函数,3个数相乘
num4=lambda x,y,b:xyb #定义一个变量，x，y，b代表形参，后面要：号添加xyb要做的行为
print(num4(5,4,4)) #输出这个变量，然后写出来实参

递归函数
递归？----------有层次，有逻辑，有顺序
定义：在函数内部，自己调用自己，也就是返回自身
阶乘？--------3！=123
5！=12345
n！=12345…*n-1 *n
举例：def fun(n):
if n==1:
return 1
return fun(n-1)*n
print(fun(10))

拆包----------对函数的返回值进行拆包
拆包是定义的变量数一定要和函数的返回值的个数相同
元祖字典列表都可以拆包
对字典进行拆包输出的只有字典的键
举例：def func():
name=“林木”
age=18
sex=“男”
return name,sex,age #把3个变量返回给返回值
mingzi,nianling,xingbie1=func() #定义3个名字来接受返回值对应的元素，注意必须是拆包是定义的变量数一定要和函数的返回值的个数相同
print(mingzi) #分别输出几个变量的元素
print(nianling) #分别输出几个变量的元素
print(xingbie1) #分别输出几个变量的元素

文件
可以在python里创建文件读取文件在文件里写
作用：存储数据
1.创建和打开文件
语法：需要用到python的内置函数1-----open（）
格式：变量名=open（“文件名.txt”,“打开模式”，编码）----如果不写编码encoding=“utf-8”，中文会乱码
打开模式 1.w 写
2.r 读
3.a 追加append（）
举例：f1=open(“2002A.txt”,“w”,encoding=“utf-8”)
注意：1.当模式是w，a的时候，如果有文件，就打开文件，如果没有，会自动创建，
2.当模式是r的是个代表只能读
3.当以 w方式打开文件，并且写入内容的时候，原内容会被覆盖掉
4.当以 a方式打开文件，并且写入内容的时候，原内容不会被覆盖掉
第二种方式：with open(“6.13文件.txt”,“w”,encoding=“utf-8”)as f:
自带关闭
2.关闭文件
格式：变量名.close（）
举例：f1=open(“2002A.txt”,“w”,encoding=“utf-8”) #创建文件
f1.close() #关闭文件

3.写入文件内容
格式：变量名.write(“内容”) -------内容是字符串形式的
如果文件不关闭，内容不会被保存，如果内容想要被保存，并且不关闭文件，用变量名.flush()
有没有一种写法，不用flush也不用close（），文件内容是否会被保存？

举例：f1=open(“2002A.txt”,“w”,encoding=“utf-8”) #创建文件
f1.write(“我是帅哥”) #在文件写内容
f1.close() #关闭文件

4、读取文件内容
定义：一定要以读（r）的模式打开文件
【read(n)】代表读多少个字符
如果默认read（）会把所有的信息读取出来
格式：变量名.read(n)
举例：f2=open(“2002A.txt”,“r”,encoding=“utf-8”)

f2.write(“买它买它买它”+"\n")

print(f2.read())

【readline()】 --------一次读一行
格式：变量名.readline()
举例：f2=open(“2002A.txt”,“r”,encoding=“utf-8”)

f2.write(“买它买它买它”+"\n")

print(f2.readline())

【readlines()】会把所有的信息读取出来返回到一个列表里
格式：变量名.readlines()
举例：f2=open(“2002A.txt”,“r”,encoding=“utf-8”)

f2.write(“买它买它买它”+"\n")

print(f2.readlines())

【seek(数字)】#seek字节值3个为一个字,指定从哪个字以后开始读
举例: f2=open(“2002A.txt”,“r”,encoding=“utf-8”)
f2.seek(9) #seek字节值3个为一个字，从9以后开始输出内容
print(f2.read()) #一个字节读取一个字，读取数量，不填字节默认全部读
f2.close() #关闭

文件夹，又叫目录，在python中，文件夹的操作/目录的操作
【os模块】
1.import os-----------导包

2.对文件进行重命名
格式：os.rename（“旧名”，“新名”）
举例：import os
os.rename(“1.txt”,“5.txt”) #第一个是旧文件名，第二个新文件名

3.删除文件
格式：os.remove(“文件名”)
举例：import os
os.remove(“5.txt”) #remove里面的值是删除文件的名字

4.创建文件夹
格式os.mkdir（“文件名”）
举例：import os
os.mkdir(“2002a”) #mkdir里面加填入要创建文件夹的名字

5.获取当前目录
路径分为两种：相对路径和绝对路径。
相对路径：1.一当前的路径为中心，去查找指定的文件
2. .代表当前目录
3. ./上级目录
绝对路径：1.有盘符 C/D/E/F
2.可以通过文件的右键中的属性查看位置信息
格式：os.getcwd（）
举例：import os
print(os.getcwd()) #获取当前文件夹位置

6.删除文件夹
格式：os.rmdir(“文件夹名字”)
举例：import os
os.rmdir(“11111111”) #删除文件夹

【面向对象】
面向过程--------------函数
定义：处理问题的每一步，都需要亲身去经历，代码从上到下执行

面向对象-------类
定义：只关注结果，不关乎过程，通过对象调用类方法
使用面向对象包含两个：类------抽象的
对象-----实际存在的

1.创建类
格式：class 类名（）：------类名也要遵循标识符的命名方法和命名规则
举例：class person(): #定义一个类
def eat(self): #定义一个函数
print(“吃贺拉斯”)
def run(self): #定义另一个函数
print(“跑步”)
wuzhihao=person() #调用类，就是创建对象
wuzhihao.eat() #输出面向对象的行为
wuzhihao.run() #输出面向对象的行为

2.创建对象
对象名=类名（）
1.添加和获取，对象的属性
在创建对象后，自己添加属性
2.在方法内部通过self获取对象的属性
在对象里定义属性属性，在类方法里通过self调用

_ init _ 魔法方法---------python类提供的以_ 开头结尾
1.在魔法方法 init _ 里创建的属性，以下所有方法都可以使用
2.变量初始化和赋值
举例1：class LOL():
def init(self): #初始化和赋值
self.name=“js” #实例属性
self.hit_point=“1000” #实例属性
self.sex=“男”
def jiansheng(self): #实例方法
print("%s说:你的剑就是我的剑,生命值是%s,性别%s"%(self.name,self.hit_point,self.sex))
def dema(self):
print(“人在塔在”)
def huonv(self):
print(“你见过我的小熊吗？”)
hero=LOL() #创建对象
hero.jiansheng() #调用剑圣的函数

举例2：class person:
#魔法方法：python类提供的以_ 开头 _结尾
def init(self,name,age): #初始化和赋值，实例方法
self.name=name #实例属性
self.age=age #实例属性

def human(self):                                      print("姓名是:%s,年龄是%d"%(self.name,self.age))

Catherine=person(“李树萍”,18)

Catherine.human()

mankind=person(name=input(“请输入姓名:”),age=int(input(“请输入年龄:”)))
mankind.human()

_ str() _ -----------通过输出对象名，显示信息的，需要使用return和格式化输出，将信息输出
举例：class peron():
def init(self,name,age):
self.name=name
self.age=age
def linmu(self):
print(“姓名叫%s,年龄%s岁”%(self.name,self.age))
def str(self):
return (“姓名叫%s,年龄%s岁”%(self.name,self.age))
Catherine=peron(“李树萍”,“18”)

Catherine.linmu()

print(Catherine)

del-------------删除对象的，创建一个实例方法def del(self):，写入要删除的对象
下面输出del加对象才会执行，不然不会执行
class peron():
def init(self,name,age):
self.name=name
self.age=age
def linmu(self):
print(“姓名叫%s,年龄%s岁”%(self.name,self.age))
def str(self):
return (“姓名叫%s,年龄%s岁”%(self.name,self.age))
def del(self):
print("%s被干掉了"%self.name) #删除对象，下面必须输出del加对象名才能执行
Catherine=peron(“李树萍”,“18”)

Catherine.linmu()

print(Catherine)
del Catherine #删除对象，Catherine
print(Catherine) #输出一下删除的对象是否存在，不存在会报错

继承
父类-------是一个类
字类--------是一个类
子雷继承父亲的
【单继承】
1.子类只继承一个父类
2.子类可以使用父类的实例属性和实例方法
3.在子类的类名括号里写上父类的名字就ok了
举例：class master(object): #object代表类的最高级别
def init(self):
self.name=“古代煎饼果子大法” #实例属性
def zuo_bing(self):
print(“用%s做煎饼果子，5块一个”%self.name)
fuqin=master()
fuqin.zuo_bing()

class son(master): #子类可以继承父类的实例属性，在括号写入父类的类名皆可以了
pass
erzi=son() #创建子类对象
erzi.zuo_bing() #调用父类的实例属性

【多继承】
1.在子类的括号里，可以写多个父类的名
2.当多个父类的实例属性和实例方法相同时默认调用括号里的第一个父类的实例属性，
和实例方法
3.当多个父类名的实例方法不相同时，子类调用时不影响
举例:class master(object): #object代表类的最高级别
def init(self):
self.name=“古代煎饼果子大法” #实例属性
def zuo_bing(self):
print(“用%s做煎饼果子，5块一个”%self.name)
def yan(self):
print(“大烟袋”)

fuqin=master()

fuqin.zuo_bing()

class schol():
def init(self):
self.name1=“学校煎饼果子大法” #实例属性
def zhuo_bing(self):
print(“用%s做煎饼果子，5块一个”%self.name1)
def xiao_yan(self):
print(“小烟袋”)

class son(schol,master): #当多个父类的实例属性和实例方法相同时默认调用括号里的第一个父类的实例属性，
#和实例方法
pass
erzi=son() #创建子类对象

erzi.zuo_bing() #调用父类的实例属性

erzi.zhuo_bing()
erzi.yan()
erzi.xiao_yan()

1.子类重写和父类相同属性和方法
当子类的属性和方法与父类的属性方法相同时，优先使用子类内部创建的属性和方法。
2.在子类中调用父类相同的属性和方法

3.在子类中，调用和父亲同名的实例属性和实例方法
1.先写一个方法名
2.用父亲名.init(self)
3.调用实例属性 self.属性名
4.调用实例方法父类名.方法名（self）

【第二种】
使用super调用父类的方法
2.用super（）.init()
3.调用实例方法super（）.方法名（）

举例：class master(object): #object代表类的最高级别
def init(self):
self.name=“古代煎饼果子大法” #实例属性
def zuo_bing(self):
print(“用%s做煎饼果子，5块一个”%self.name)
def yan(self):
print(“大烟袋”)

fuqin=master()

fuqin.zuo_bing()

class schol(): #学习的类
def init(self):
self.name=“学校煎饼果子大法” #实例属性
def zuo_bing(self):
print(“用%s做煎饼果子，5块一个”%self.name) #实例方法
def xiao_yan(self):
print(“小烟袋”)

class son(schol,master): #当多个父类的实例属性和实例方法相同时默认调用括号里的第一个父类的实例属性，
def init(self):
self.name = “合并煎饼果子大法” # 实例属性
def zuo_bing(self):
print(“用%s做煎饼果子，5块一个” % self.name)

def make_old(self):           #在子类的类里边，调用父类的煎饼大法master.__init__(self)        #调用出来父类的魔法方法print("实例属性%s"%self.name)      #调用出来父类的实例属性master.zuo_bing(self)             #调用出来父类的实例方法和实例方法
super().__init__()              #同理在子类里面调用父类魔法方法super().zuo_bing()             #同理在子类里面调用父类的实例方法，属性调用不了

erzi=son() #创建子类对象

erzi.zuo_bing() #调用父类的实例属性

erzi.zuo_bing() #调用出来子类自己的实例属性和方法

erzi.yan()

erzi.xiao_yan()

erzi.make_old() #在子类中调用父类的方法

私有属性
私有方法
定义：只需要在实例方法和实例属性前面加上_ _
特征：1.不能被继承，子类不能使用
2.对象不可以访问
3.一般用来处理类内部的事情，起到安全作用
4.可以通过实例属性调用和修改私有属性的值
实例方法可不可以调用私有属性？------------可以
通过实例方法可不可以修改私有属性的值？----------可以
举例：class father_money():
def init(self):
self.num=“100w” #实例属性
self.__money=“1000w” #私有属性

def son_spead(self):        #实例方法print("用%s花钱"%self.num)def money_spead(self):        #私有方法print("用%s买包包"%self.__money)def amend_money(self):             #实例方法self.__money="500w"           #通过实例方法修改私有实例属性print("买车了还剩%s"%self.__money)

son=father_money()

print(son.num)

print(son.money)

son.son_spead()

son.money_spead()
son.amend_money()

面向对象的特征：
【封装】
定义：1.将属性和方法封装到类里，通过对象调用
2.用户只能通过实例属性和方法调用，不清楚类里的数据结构
3.对类的属性和方法增加防控权限，提高程序的可维护性

【继承】
定义：1.实现重复利用的重要手段
2.子类可以拥有父类的实例属性和实例方法，还可以有自己的实例属性和实例方法
【多态】
定义：1.子类继承了父类特征的同时，也具备了自己的特征，并且能够实现不同的效果

类属性和实例属性
【实例属性】定义在_ init _ 方法里以self.开头的属性，对象和实例方法都可以调用实例属性
【类属性】
1.在创建类后，直接用变量名定义的属性，分为公有类属性，和私有类属性
2.实例方法不可以调用类属性
3.对象可以调用公用类属性
4.通过对象修改类属性

类方法和静态方法
1.创建一个类方法
格式：@classmethod
def 方法名（cls）：
pass

2.类方法可以修改类属性
格式 @classmethod
def 方法名（cls）：
cls,属性名=“新的属性”
对象名.方法名（）
输出对象名.属性名

【静态方法】
格式：@staticmethod #静态方法
def 方法名():
print(“我的美女是%s”,类名.类属性名)
通过对象调用
通过类名，方法名调用

举例：class car():
cars=“奥迪” #类属性只能通过对象调用，不可以通过init的self方法调用
money=“100w” #私有类属性
meinv=“花花” #私有类属性
def init(self): #实例属性
self.name=“林木”
self.age=18

def my_car(self):print("我的名字是",self.name,"年龄",self.age)#类方法
@classmethod
def girl(cls):print("我的车是%s，我的美女是%s"%(cls.cars,cls.meinv))@classmethod
def remodification_girl(cls):cls.meinv="youki"@staticmethod      #静态方法
def girls():print("我的美女是%s",car.meinv)    #通过类名，和类属性来输出

xiaowu=car()

xiaowu.my_car()

print(xiaowu.cars) #对象调用公用类属性

xiaowu.money=“200w” #通过对象修改公有类属性

print(xiaowu.money) #输出公有类属性

xiaowu.girl() #调用类方法

xiaowu.remodification_girl() #调用修改的类属性

print(xiaowu.meinv) #输出更改过的类方法，youki

xiaowu.girl() #静态方法调用类方法

_ new _
1.参数是cls
2.必须有返回值
3.返回的是实例，一般使用object._ new _(cls)
单列模式
举例：class food():
def init(self):
print(“这是init方法”)

def __new__(cls, *args, **kwargs):print("这是new方法")return object.__new__(cls)

food()

单例属性
举例：实现__new__方法，然后将类的一个实例绑定到类变量_instance上，如果cls.instance为
None,则说明该类还没有被实例化过，new一个该类的实例，并返回：如果cls.instance不为None，
直接返回_instance。
class person():
__instance=None

def __new__(cls, *args, **kwargs):if not cls.__instance:cls.__instance=object.__new__(cls)return cls.__instancedef __init__(self,name,age):self.name=nameself.age=age

a=person(“昊昊”,18)
b=person(“波波”,18)

print(id(a))
print(id(b))
print(a.age)
print(b.age)

【异常】----报错
1.特征：代码报错之后，下面的代码不能被运行
（捕获异常）
格式：try：----------except异常
举例：try：
异常中的代码
except 报错的格式名：
print（提示报错信息）

（异常处理中抛出异常）-----
格式：try：
except Exception as 变量名：
print（变量名）
else：
print（“可以正常运行”）

（异常不管报不报错都会输出的）
格式：finally: #不管有没有报错，都会执行
print(“欢迎使用python”)

举例：try:
num=int(input(“请输入数字:”))
num1=num+“10”
print(num1)
except Exception as u: #捕获异常
print(“有错误:”,u)
else: #如果没有错，会执行以下代码
print(“可以继续运行”)

finally: #不管有没有报错，都会执行
print(“欢迎使用python”)

报错的常见类型
NameError ---------变量名不存在
TypeError---------类型错误
SyntaxError--------语法错误
ImportError--------导入的模块错误
IndentationError---------缩减错误
IOError--------输入输出错误
IndexError---------索引超出范围错误
AttributeError---------属性错误

2.模块
导包--------到python中自带的包
random---------随机模块
os-----------文件模块
math----------数学模块
导包的快捷键
alt+回车-------导包--------也是可以安装第三方的模块
注意：导包的语句会在最上方

导包的3种模式
import os
import rannom
from random import randint

我们自己定义的模块
1.只要是我们创建的py文件，那么这个文件里的函数和类都可以调用
举例：#自定义模块

from demo(调用的文件名) import func(调用demo文件里面的函数func) #只能导出一个模块

from demo（调用的文件名） import * #可以导demo里的所有代码
mokuai=func(3,4) #定义一个变量，调用demo文件函数里面实参
print(mokuai) #输出函数

Catherine 成长记第一篇相关推荐

eclipse弃坑记第一篇之在idea上配置Tomcat环境并创建Javaweb项目的详细步骤原创
IntelliJ IDEA是一款功能强大的开发工具,在代码自动提示.重构.J2EE支持.各类版本工具(如git.svn.github).maven等方面都有很好的应用. IntelliJ IDEA有免 ...
小小爬虫成长记第一天
这是我第一次对于一种语言产生了一种浓厚的兴趣,所以我决定好好学习python,后面的日子我都将和大家分享一下我这个小小小爬虫成长心得: 首先分享一下关于安装pycharm2018 1.1的收获吧,其实 ...
小T成长记-操作系统篇1-一条小小的除法指令引起的翻车事故
1 事故背景人物:小T(研发中心-操作系统开发工程师):小S(产品开发部-软件工程师) 背景:公司正在联合开发基于MIPS架构的产品.研发中心负责操作系统平台开发,产品开发部负责业务逻辑开发.目前操 ...
屌丝giser成长记-大学篇
作为一名屌丝giser的我,刚接触gis专业是2007年的大一,好悲催,当时gis这个专业是被调剂的,我压根都不知道gis为何物,那时候gis冷门的一逼,报名这个专业的寥寥无几.记得那时候得知被调剂到 ...
【吃瓜教程】随记第一篇
机器学习:将"经验"以"数据"的方式存储,产生模型算法-学习算法->产生模型-分析新的数据-给出判断. 1.有监督学习(标记样本) 预测连续值->回 ...
架构师成长之旅_第一篇：插件与框架是什么？
架构师成长之旅_第一篇:c++插件开发目录踏入工作前的准备框架是什么? 多人开发一.踏入工作前的准备在即将踏入工作时,最主要的是你的代码量和你编码能力,最重要的是你的代码质量,在编码界代码质 ...
红薯微剧场 | 开源众包发包记第一集 —— 前端篇
开源众包发包记 ---玩转众包第一集巧引外援.顺度难关---前端开发项目篇丁酉年11月,北京的天气已经逐渐寒凉,部分办公司的灯光已熄灭,办公室的窗户上印衬着佳佳略显倦怠的容颜.虽然小风 ...
【论文写作】-我的第一篇论文形成记(投稿过程、课题来源、python与数学学习、实验设计、论文思路建立与写作、回复审稿人)
我的第一篇论文形成记投稿过程背景记录课题来源-本科毕业设计 python及数学学习实验设计调参阶段实验阶段论文思路建立论文写作回复审稿人总结投稿过程 2022年12月28日投A ...
技术小白成长之路 - 谷歌云端 GCP Cloud Engineering - 第一篇 - 核心架构 Core Infrastructure
谷歌云端 GCP Cloud Engineering Certificate - 第一篇 - 核心架构 Core Infrastructure 谷歌云端平台GCP简介 1. 谷歌云端平台GCP资源层次 ...

Catherine 成长记第一篇

基础知识

dict111.pop(“age”)

print(dict111)

set01.pop() #随机删除一个元素

print(set01)

set01.remove(7) #指定删除一个元素

print(set01)

c=a+b #把a+b赋值给了c

d=a-b ##把a-b赋值给了d

return c,d 把c和d返回值了，就是没有地方输出

print(func(5,2)) 输出c和d计算的数

f2.write(“买它买它买它”+"\n")

f2.write(“买它买它买它”+"\n")

f2.write(“买它买它买它”+"\n")

Catherine=person(“李树萍”,18)

Catherine.human()

Catherine.linmu()

Catherine.linmu()

fuqin=master()

fuqin.zuo_bing()

erzi.zuo_bing() #调用父类的实例属性

fuqin=master()

fuqin.zuo_bing()

erzi.zuo_bing() #调用父类的实例属性

erzi.yan()

erzi.xiao_yan()

erzi.make_old() #在子类中调用父类的方法

print(son.num)

print(son.money)

son.son_spead()

xiaowu.my_car()

print(xiaowu.cars) #对象调用公用类属性

xiaowu.money=“200w” #通过对象修改公有类属性

print(xiaowu.money) #输出公有类属性

xiaowu.girl() #调用类方法

xiaowu.remodification_girl() #调用修改的类属性

print(xiaowu.meinv) #输出更改过的类方法，youki

from demo(调用的文件名) import func(调用demo文件里面的函数func) #只能导出一个模块

Catherine 成长记第一篇相关推荐

最新文章

热门文章