一、开发环境的搭建
-
开发环境搭建就是安装python的解释器
-
python 的解释器分类：
-
CPython(用C语言编写的python的解释器)
-
pypy(用python语言编写的python解释器)
-
IronPython(用.net编写的Python解释器)
-
Jython(用Java编写的Python解释器)
-
-
-
下载地址 www.python.org
二、基本语法
-
Python中严格区分大小写
-
Python中的每一行就是一条语句
-
Python中每一行语句不要过长
-
一条语句可以分多行编写，语句后边以\结尾
-
Python是缩进严格的语言，所以在Python中不要随便写缩进
-
在Python中使用#来表示注释，#后的内容都已属于注释，注释的内容将会被解释器所忽略，我们可以通过注释对程序进行解释说明。
1.字面量和变量
-
字面量：即字面的值，程序中可以直接使用字面量；e.g. 1、2、3、4、5、6、'HELLO'
-
变量：变量可以用来保存字面量，并且变量中的保存的字面量是不定的；e.g. a=10; a=20;
2.变量和标识符
-
变量
-
Python中使用变量不需要声明，直接为变量赋值即可
-
未赋值的变量不可使用
-
Python是一个动态类型的语言，可以为变量赋值任意类型的值，也可以任意修改变量的值
-
e.g. a='hello'
-
-
标识符
-
在Python中所有可以自主命名的内容都属于标识符
-
e.g. 变量名、函数名、类名
-
标识符必须遵循标识符的规范
-
标识符中可以包含字母、数字、下划线，但是不能以数字开头；e.g. demo_1
-
标识符不能是Python中的关键字和保留字
-
命名规范
-
下划线命名法：所有字母小写，单词之间使用_分割；e.g. max_length
-
帕斯卡命名（驼峰命名）：每个单词首字符大写，其余字母小写；e.g. MaxLength
-
-
-
-
数据类型
-
数值：整数、浮点数、复数
-
整型
-
所有整数都是int类型，Python中的整数的大小没有限制，可以是一个无限大的整数；e.g. c=99999999999999999999
-
如果数字的长度过大，可以使用下划线作为分隔符；e.g. c=123_456_789，打印不受影响
-
d= 0123 ；十进制的数据不能以0开头
-
其他进制的整数，只要是数字打印时一定是以十进制的形式展示
-
二进制 0b开头；c=0b10
-
八进制 0o开头
-
十六进制 0x开头
-
-
也可以通过运算符来对数字进行运算，并且可以保证整数运算的精确
-
-
浮点数（小数），在Python中所有的小数都是float类型
-
c=1.23
-
c=4.56
-
对浮点数进行运算时，可能会得到一个不精确的结果
-
c=0.1+0.2 #0.30000000004
-
-
-
-
字符串
-
字符串用来表示一段文本信息，字符串是程序中使用的最多的数据类型
-
在Python中字符串需要使用引号引起来； s='hello'
-
引号可以是双引号，也可以是单引号，但是不能混着使用
-
s='hello'
-
s="hello"
-
-
相同的引号之前不能嵌套
-
单引号和双引号不能跨行使用（需要借助换行符\）
-
使用三重引号来显示一个长字符串''' ''' 或""" """(支持换行)
-
转义字符，使用\作为转义字符，通过转义字符，可以在字符串中使用一些特殊的内容
-
e.g. \t 表示制表表
-
e.g. \n 表示换行符
-
e.g. \uxxxx表示unicode编码
-
-
格式化字符串
-
字符串之间用加法，进行拼接
-
占位符
-
%s在字符串中表示任意字符
-
%f 浮点数占位符
-
%d 整数占位数
-
-
格式化字符串f
-
在字符串前添加一个f来创建一个格式化字符串
-
f 'hello {a}{b}'
-
-
字符串复制（将字符串和数字相乘）
-
a ='abc'
-
a=a*2
-
输出为：abcabc
-
-
-
布尔值(bool)
-
主要用来做判断逻辑
-
布尔值一共有两个Ture（真）和False（假）
-
布尔值实际上也属于整型，Ture相当于1，False相当于0
-
-
None(空值)
-
None专门用来表示不存在
-
-
-
数据类型检查
-
type()用来检查值的类型
-
-
3.对象（object）
-
初步认识
-
python 是一门面向对象的语言
-
程序运行当中，所有的数据都是存储到内存当中然后再运行
-
对象就是内存中专门用来存储指定数据的一块区域
-
对象实现上就是一个容器，专门用来存储数据
-
-
对象的结构
-
每个对象中都要保存三种数据
-
id(标识)
-
id用来标识对象的唯一性，第一个对象都有一个唯一的id
-
-
对象的id相当于人的身份证号一样
-
可以通过id()函数来查看对象的id
-
id是由解释器生成的，在CPython中，id就是对象的内存地址
-
id一旦创建，则它的id永远不可改变
-
-
type（类型）
-
类型用来标识当前对象所属的类型
-
e.g. int , float, srt bool ...
-
类型决定了对象哪些功能
-
Python是一门强类型的语言，对象一旦创建类型便不能修改
-
-
value（值）
-
值就是对象中存储的具体的数据
-
对于有些对象值是可以改变的
-
对象分为两大类，可变对象/不可变对象
-
-
-
变量与对象
-
对象并没有直接存储到变量中，在Python中变量更像是给对象起了一个别名
-
变量中存储的不是对象的值，而是对象的id(内存地址)，当我们使用变量时，实际上就是在通过对象id在查找对象
-
变量中保存对象（id），只有在为变量重新赋值时才会改变
-
变量和变量之间是相互独立的，修改一个变量不会影响另外一个变量
-
4.类型转换与运算符
-
类型转换
-
所谓的类型转换，将一个类型的值对象转换为其他对象
-
类型转换不是改变对象本身的类型，而是根据当前对象的值创建一个新对象
-
类型转换四个函数
-
int()
-
可以用来将其他的对象转换为整型
-
规则
-
布尔值：Ture -> 1 False -> 0
-
浮点数：直接取整，省略小数点后的内容
-
字符串：合法的整数字符串，直接转换为对应的数字；如果不是一个合法的整数字符串，则报错ValueError;
对于其他不可转换为整型的对象，直接抛出异常ValueError
-
-
int() 函数不会对原来的变量产生影响，它是对象转换主指定的类型并将其作为返回值返回
-
如果希望修改原来的变量，则需要对变量进行重新赋值
-
-
float()
-
与int()基本一致，不同的是它会将对象转换为浮点数
-
-
str()
-
可以将对象直接转换为字符串
-
-
bool()
-
可以将对象转换为布尔值，任何对象都可以转换为布尔值
-
规则
-
对于所有表示空性的对象都会转换为False，其余转换为Ture
-
哪些表示的空性：0、None、''、........
-
-
-
-
运算符（操作符）
-
运算符可以对一个值或多个值进行运算或各种操作
-
运算符的分类
-
算术运算符
-
加法运算符(+)， 如果是两个字符串之间的进行运算，则会进行拼串操作
-
减法运算符(-)
-
乘法运算符(*)，如果将字符串和数据相乘，则会对字符串进行复制操作，将字符串重复指定次数
-
除法运算符(/)，运算时结果总会返回一个浮点类型
-
整除(//)，只会保留计算后的整数位，总会返回一个整型
-
幂运算(**)，求一个值的几次幂
-
取模(%)，求两个数相除的余数
-
-
赋值运算符
-
= 可以将等号右侧的值赋值给等号左侧的变量
-
+= - > a +=5 相当于 a =a + 5
-
-=
-
*=
-
**=
-
/=
-
//=
-
%=
-
-
比较运算符（关系运算符）
-
比较两个值之间的关系，总会返回一个布尔值，如果关系成立，返回True，否则返回False
-
字符串进行比较时，是比较的unicode编码，逐位比较
-
">" ：比较左侧值是否大于右侧值
-
">="：比较左侧值是否大于等于右侧值
-
"<"：比较左侧值是否小于右侧值
-
"<="：比较左侧值是否小于等于右侧值
-
"=="：比较两个对象的值是否相等
-
"!="：比较两个对象的值是否不相等
-
is：比较两个对象是否为同一个对象，比较的是对象的Id
-
is not ：比较两个对象是否不是同一个对象，比较的是对象的id
-
-
逻辑运算符
-
逻辑运算符主要用来做一些逻辑判断
-
not 逻辑非
-
not 可以对符号右侧的值进行非运算
-
对于布尔值，非运算会对其进行取反操作，True变False，False变True
-
对于非布尔值，非运算会将其转换为布尔值，然后再取反
-
-
and 逻辑与
-
and可以对符号两侧的值进行与运算
-
只有在符号两侧的值都为True时，都会返回True，只要有一个False就返回False
-
Python中的与运算是短路的与，第一值为False就不会再看第二个
-
-
or 逻辑或
-
or可以对符号两侧的值进行或运算
-
或运算两个值中只要有一个True，就会返回True
-
Python中的或运算是短路的或，第一个值为True就不会再看第二个
-
-
非布尔值的与或运算
-
当我们对非布尔值进行与或运算时，Python会将其当做布尔值运算，最终会返回原值
-
与运算的规则
-
与运算是找False，如果第一个值是False，则不看第二个值
-
如果第一个值是False，则直接返回第一个值，否则返回第二个值
-
-
或运算的规则
-
或运算是找True，如果第一个值是True，则不看第二个值
-
如果第一个值是True，则直接返回第一个值，否则返回第二个值
-
-
-
-
条件运算符（三元运算符）
-
语法：语句1 if 条件表达式 else 语句2
-
执行流程
-
条件运算符在执行时，会先对条件表达式进行求值判断
-
如果判断结果返回Ture，则执行语句1，并返回执行结果
-
如果判断结果返回False，则执行语句2，并返回执行结果
-
-
-
-
运算符的优先级
-
运算符的优先级可以根据优先级诉表格来查询
-
在表格中位置越靠下的运算符优先级越高，优先级越高的越优先计算
-
如果优先级一样则自左向右计算
-
实际使用中，如果碰到优先级不清楚的，可以通过小括号来改变运算顺序
-
-
三、流程控制语句
1.简介
-
python代码在执行时按照自上向下顺序执行的；通过流程控制语句，可以改变程序的执行顺序，也可以让指定的程序反复执行多次
-
流程控制语句分成两大类：条件判断语句，循环语句
2.条件判断语句（if）
-
语法：if 条件表达式 : 语句
-
执行的流程：if语句在执行时，会先对条件表达式进行求值判断
-
如果为True，则执行if后的语句
-
如果为False，则不执行
-
3.条件判断语句（if - else）
-
语法
if 条件表达式 : 代码块 else : 代码块 -
执行流程
-
if - else 语句在执行时，先对if后的条件表达式进行求值判断
-
如果为True，则执行if后的代码块
-
如果为False，则执行else后的代码块
-
4.条件判断语句（if - elif - else）
-
语法
if 条件表达式： 代码块 elif 条件表达式： 代码块 elif 条件表达式： 代码块 elif 条件表达式： 代码块 else: 代码块 -
执行流程
-
if - elif - else 语句在执行时，会自上向下依次对条件表达式进行求值判断
-
如果表达式的结果为True，则执行当前代码块，然后语句结束
-
如果表达式的结果为False，则继续向下判断，直到找到True为止
-
如果所有表达式都是False，则执行else后的代码块
-
if- elif - else中只会有一个代码块会执行
-
5.流程控制语句-练习
-
练习1： 编写一个程序，获取一个用户输入的整数。然后通过程序显示这个数是奇数还是偶数
number = int(input('请输入一个整数：')) if number < 0: print('请输入大于0的数') elif number == 0: print('0既不是可数，也不是偶数') else: if number%2 == 0: print(number,'是偶数') else: print(number,'是奇数') -
练习2：编写一个程序，检查任意一个年份是否为闰年（如果一个年份可以被4整除不能被100整除，或者可以被400整除，这个年份就是闰年）
year = int(input('请输入一个年份：')) if (year%4 == 0 and year%100 != 0) or (year%400 == 0): print(year,'是闰年') else: print(year,'不是闰年') -
练习3：我家的狗5岁了，5岁的狗相当于人类的10.5岁，然后每增加一年就增加4岁；那么5岁的狗相等于人类的年龄就应该是10.5+10.5+4+4+4=33岁；编写一个程序，获取用户输入的狗的年龄，然后通过程序显示其相当于人类的年龄。如果用户输入的是一个负数，请显示一个提示信息
human_age=0 dog_age = int(input('请输入小狗的年龄：')) if dog_age <= 0: print('请输入一个正确的年龄（大于0）：') else: if dog_age <= 2: print('小狗的%d相当于人类的%d岁'%(dog_age,dog_age*10.5)) else: #两岁前的年龄 human_age=10.5*2 #两岁后的年龄 human_age += (dog_age-2)*4 print('小狗的%d岁相当于人类的%d岁' %(dog_age,human_age)) -
练习4：从键盘输入小明的期末成绩：
-
当成绩为100时，奖励1辆BMW
-
当成绩为[80-99]时，奖励1台iphone
-
当成绩为[60-79]时，奖励1本参考书
-
其他时，什么奖励也没有
score = int(input('请输入小明的期末成绩（0~100）：')) if 0 <= score <= 100: if score == 100: print('奖励1辆BWM') elif score >= 80: print('奖励1台iphone') elif score >= 60: print('奖励1本书！') else: print('没有任何奖励！') else: print('输入内容不合法，请重新输入')
-
-
练习5：大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件
-
高：180cm以上 ；富：1000w以上；帅：500以上；
-
如果这三个条件同时满足，则：我一定要嫁给他
-
如果三个条件有为真的情况，则：嫁吧，比上不足，比下有余
-
如果三个条件都不满足，则：不嫁！
height = int(input('请输入身高(cm)：')) deposit = int(input('请输入存款(w)：')) handsome = int(input('请输入帅气值：')) if height >= 180 and deposit >= 1000 and handsome >= 500: print('我一定要嫁给他。') elif height >= 180 or deposit >= 1000 or handsome >= 500: print('嫁吧，比上不足，比下有余。') else: print('不嫁，哥乌恩。')
-
四、循环控制语句
1.简介
-
循环语句可以使指定的代码块重复指定的次数
-
循环语句分为两种，while、for
2.while循环
-
语法
while 条件表达式:
代码块
-
执行流程
-
while语句在执行时，会先对while后的条件表达式进行求值判断
-
如果判断结果为True，则执行循环体（代码块）
-
循环体执行完毕，继续对条件表达式进行求值判断，以此类推
-
直到判断结果为False，则循环终止
-
3.while循环练习
-
练习1 求100以内所有奇数之和
i = 1 result = 0 while i <= 100: if i % 2 != 0: result += i i += 1 print('result=', result) -
练习2 求100以内所有7的倍数之和，以及个数
i = 7 result = 0 appearance_times = 0 while i <= 100: result += i appearance_times += 1 i += 7 print('7以内的倍数=%d,7以内的个数为%d' % (result, appearance_times)) -
练习3 求1000以内所有的水仙花数
limit = int(input('请输入水仙花数的范围：')) if len(str(limit)) < 3: print('请重新输入，水仙花数最少是三位数！') else: i = 100 while i < limit: total = 0 flower_list = list(str(i)) flower_len = len(flower_list) for f in flower_list: total += int(f)**flower_len if total == i: print('水仙花数:%d' % i) i += 1 -
练习4 获取用户输入的任意数，判断其是否是质数
num = int(input('请输入一个数字：'))
i = 2
flag = True
while i < num:
# 判断num是否能被i整除
# 如果num能被i整除，那么num一定不是质数
if num % i == 0:
flag = False
i += 1
if flag:
print(num, '是质数')
else:
print(num, '不是质数')
优化：
from time import *
i = 2
start =time()
while i <= 100000:
# 创建一个变量，标记i的状态，默认i是质数
flag = True
j = 2
# 质数不包含1和它本身，所以要j<i
while j <= i**0.5:
if i % j == 0:
flag = False
break
j += 1
if flag:
print(i)
i += 1
end = time()
print()
print(end-start,'秒')
-
练习5 嵌套循环
打印图形
*
**
***
****
*****
i = 0
while i < 5:
j = 0
while j < 5-i:
print('*',end='')
j += 1
print()
i += 1
-
练习6 嵌套循环
打印图形
*****
****
***
**
*
i = 0
while i < 5:
j = 0
while j < 5-i:
print('*',end='')
j += 1
print()
i += 1
-
练习7 打印九九乘法表
i = 0
# 外循环控制行
while i < 9:
i += 1
j = 0
#内循环控制列
while j < i:
j += 1
print(f'{j}*{i}={i*j}',end='\t')
print()
#输出结果：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
-
求100以内的质数
i = 2 while i <= 100: # 创建一个变量，标记i的状态，默认i是质数 flag = True j = 2 # 质数不包含1和它本身，所以要j<i while j < i: if i % j == 0: flag = False j += 1 if flag: print(i,end=' ') i += 1
4.跳出循环
-
break与continue
-
break 立即退出当前循环(包括else)
-
e.g.
i = 0 while i < 5: print(i) break i += 1 else: print('循环结束') -
-
continue 跳出本次循环，进行下一次循环
-
e.g.
i = 0 while i < 5: i += 1 if i == 3: continue print(i) #输出结果： 1 2 4 5
-
-
五、数据结构-序列
1.序列(squence)
-
序列是Python中最基本的一种结构
-
数据结构指计算机中数据存储的方式
-
序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置(索引)，并且序列中的数据会按添加顺序来分配索引
-
序列的分类
-
可变序列（序列中的元素可以改变）
-
列表(List)
-
-
不可变序列（序列中的元素不可改变
-
字符串(str)
-
元组(tuple)
-
-
-
序列的通用操作(使用list演示)
# + 可以将两个列表拼接为一个列表 my_list = [1, 2, 3] + [4, 5, 6] print(my_list) # * 可以将列表重复指定的次数 my_list = [1, 2, 3] * 3 print(my_list) # in用来检查指定元素是否存在于列表中 # 如果存在，返回True，否则返回False print(7 in my_list) # not in用来检查指定元素是否不在列表中 # 如果不存在，返回True，否则返回False print(5 not in my_list) print(1 not in my_list) # len()获取列表中的元素的个数 # min()获取列表中的最小值 # max()获取列表中的最大值 arr = [20, 41, 96, 3, 14] print(min(arr), max(arr)) ''' 两个方法(method)，方法和函数基本上一样，只不过方法必须通过[ 对象.方法() ]的形式调用 xxx.print() 方法实际上就是和对象关系紧密的函数 s.index() 获取指定元素在列表中的第一次出现时索引 ''' arr = [20, 41, 96, 3, 14, 55, 20, 41,20] print(arr.index(20)) # index() 第二个参数，表示查找的起始位置，第三个参数表示查找的结束位置 print(arr.index(20, 2, 7)) # s.count() 统计指定元素在列表中出现的次数 print(arr.count(20)) #输出结果： [1, 2, 3, 4, 5, 6] [1, 2, 3, 1, 2, 3, 1, 2, 3] False True False 3 96 0 6 3
2.列表(list)
-
对象是Python中的一个对象
-
对象(object)就是内存中专门用来存储数据的一块区域
-
之前我们学习的对象，像数值，它只能保存一个单一的数据
-
列表中可以保存多个有序的数据
-
列表的使用
-
列表的创建
-
通过[ ]创建列表，e.g. my_list = [ ]
-
列表存储的数据，称为元素
-
一个列表中可以存储多个元素，也可以创建列表时，来指定列表中的元素；e.g. my_list = [10]
-
当向列表中添加多个元素时，用逗号分隔元素；e.g. my_list =[10,20,30,40,50]
-
列表中可以保存任意的对象
-
列表中的对象都会按照插入的顺序存储到列表中，第一个元素对象保存到第一个位置，第二个元素保存到第二个位置
-
通过索引(index)来获取列表中的元素，索引是元素在列表中的位置，列表中的每个元素都有一个索引
-
索引从0开始，索引可为负数，即从尾部的开始数
-
通过索引获取列表的数据，语法：list_name[索引]
-
获取列表的长度，列表中元素的个数，len()函数，通过该函数可以获取列表的长度；获取到的长度的值，是列表的最大索引+1
-
-
操作列表的数据
-
切片（从现有列表中，获取一个子列表）
-
语法：列表[起始:结束]
-
通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
-
做切片操作时，总会返回一个新的列表，不会影响原来的列表
-
起始和结束位置的索引都可以忽略不写
-
如果省略结束位置，则会一直截到最后
-
如果省略起始位置，则会从第一个元素开始截取
-
如果起始和结束位置全部省略，则相当于创建了一个列表的副本
my_list = ['一', '二', '三', '四', '五'] print(my_list[1:]) print(my_list[:3]) print(my_list[:]) #输出结果： ['二', '三', '四', '五'] ['一', '二', '三'] ['一', '二', '三', '四', '五']
-
语法：列表[起始:结束:步长]
-
步长表示：每次获取元素的间隔，默认值是1
my_list = ['一', '二', '三', '四', '五', '六', '七', '八', '九', '十'] # 步长为2 print(my_list[0:6:2]) # 如果步长是负数，则会从列表的后部向前取元素 # 列表做倒序操作时可用此方法 print(my_list[::-1]) #输出结果 ['一', '三', '五'] ['十', '九', '八', '七', '六', '五', '四', '三', '二', '一']
-
-
通过切片修改列表中的元素（支持所有可变序列）
ball = ['badminton', 'football', 'basketball', 'tableTennis', 'tennis', 'volleyBall'] # 新元素替换旧元素 print('替换前:', ball) ball[0:2] = ['new_badminton', 'new_football'] print('替换后：', ball) # 当设置步长时，序列中的个数必须和切片中元素的个数一致 ball = ['badminton', 'football', 'basketball', 'tableTennis', 'tennis', 'volleyBall'] print('将要替换的元素:', ball[::2]) ball[::2] = ['new_badminton2', 'new_basketball2', 'new_tennis2'] print('替换后：', ball) # 通过切片来删除元素 # del ball[0:2] # del ball[::2] # ball[0:2] = []
-
-
列表的方法
-
append(),列表尾部添加一个元素
-
s.append(元素)
-
-
insert(),向列表的指定位置插入一个元素
-
s.insert(插入位置的索引,插入的元素)
-
-
extend(),使用新的序列来扩展当前序列，需要一个序列作为参数，它会将序列中的元素添加到当前列表中
-
s.extend(序列)
-
-
clear(),清空序列
-
pop(),根据索引删除并返回被删除的元素
-
s.pop(如不传参，则删除最后一个)
-
-
remove(),删除指定元素，如果有多个元素相同，只会删除第一个
-
s.remove(元素值)
-
-
reverse(),用来反转列表元素，步长改成-1也可做相同效果
-
sort(),用来对列表中的元素进行排序，默认升序排列
-
s.sort(reverse=True) -> 降序排列
-
-
-
遍历列表
-
通过for循环来遍历列表
-
语法
for 变量 in 序列: 代码块 # for循环的代码会执行多次，序列中有几个元素就会执行几次，每执行一次就会将序列中的一个元素赋值给变量，所所以我们可以通过变量，来获取列表中的元素for b in ball: print(b) # 输出结果： badminton football basketball tableTennis tennis volleyBall
-
-
3.练习（扩展）
print('='*20, '欢迎使用员工管理', '='*20)
print('''
请选择要做的操作:
\t1. 查询员工
\t2. 添加员工
\t3. 删除员工
\t4. 退出系统
''')
employees = ['\t孙悟空\t18\t\t男\t\t花果山',
'\t猪八戒\t15\t\t男\t\t天上的某个猪圈'
]
while True:
choice = input('请选择[1-4]:')
print('=' * 55)
# 序号会发生变化，此处初始化
num = 1
# 查询员信息
if choice == '1':
print('序号\t\t姓名\t\t年龄\t\t性别\t\t住址')
for employee in employees:
print(f'{num}\t{employee}')
num += 1
# 添加员工信息
elif choice == '2':
name = input('请输入姓名：')
age = input('请输入年龄：')
gender = input('请输入性别：')
address = input('请输入住址：')
# 输入内容做拼接
info_mix = '\t' + name + '\t' + age + '\t\t' + gender + '\t\t' + address
employees.append(info_mix)
print('添加员工信息成功！')
# 删除员工信息
elif choice == '3':
del_name = input('请输入要删除的员工姓名:')
for e in range(len(employees)):
if del_name in employees[e]:
print(employees[e])
del employees[e]
break
else:
continue
elif choice == '4':
print('欢迎下次使用，谢谢!')
break
else:
print('输入错误，请重新输入！')
4.range函数(扩展)
-
range()是一个函数，可以用来生成一个自然数的序列
-
该函数需要三个参数
-
起始位置（可以省略，默认是0）
-
结束位置
-
步长（可以省略，默认是1）
-
-
range一般结合for循环使用
-
for s in range(10):
print(s)
-
5.元组
-
说明
-
元组是一个不可变的序列
-
它的操作的方式基本和列表一致的
-
在操作元组时，把元组当成为一个不可变的列表即可
-
一般当不希望数据发生改变时，就使用元组，其余情况都使用列表
-
-
创建元组
# 创建元组 my_tuple = () # 创建及初始化 # 当元组不是空元组时，括号可以省略 # 如果元组不是空元组，它里边至少要有一个逗号(,) my_tuple = (1, 2, 3, 4, 5)
-
解包
# 元组的解包(解构) # 解包指将元组当中每一个元素都赋值给一个变量 my_tuple = (10, 20, 30, 40) a, b, c, d = my_tuple print(a) print(b) print(c) print(d) # 交换a 和 b的值，这时可以利用元组的解包 a,b = b,a # 在对一个元组进行解包时，变量的数量必须和元组中元素的数量一致 # 也可以在变量前边加一个* ，这样变量将会获取元组中所有剩余的元素（形成一个列表） a , b, *c = my_tuple
6.可变对象(扩展)
-
每个对象中都保存了三个数据
-
id 标识
-
type 类型
-
value 值
-
-
列表就是一个可变对象
a = [1,2,3]
-
a [ 0 ] = 10 (改对象)
-
这个操作是在通过变量去修改对象的值
-
这种操作不会改变变量所指向的对象
-
当我们去修改对象时，如果有其他变量也指向了该对象，则修改也会在其他的变量中体现
-
-
a = [4,5,6] (改变量)
-
这个操作是在给变量重新赋值
-
这种操作会改变变量所指向的对象
-
为一个变量重新赋值时，不会影响其他的变量
-
-
一般只有在为变量赋值时才是修改变量，其余的都是修改对象
-
== 与 is
-
== != 比较的是对象的值是否相等
-
is is not 比较的是对象的id是否相等
a = [1, 2, 3] b = [1, 2, 3] print(a,b) print(id(a),id(b)) print(a == b) print(a is b) # 输出结果： [1, 2, 3] [1, 2, 3] 2213956161472 2213956482304 True False
-
六、数据结构-非序列
1.字典介绍
-
字典属于一种新的数据结构，称为映射(mapping)
-
字典的作用和列表类似，都是用来存储对象的容器
-
列表存储数据的性能很好，但是查询数据的性能很差
-
在字典中每个元素都有一个唯一的名字，通过这个唯一的名字可以快速的查找到指定的元素
-
在字典中可以保存多个对象，每个对象都会有一个唯一的名字
-
这个唯一的名字，我们称其为键(key)，通过key可以快速的查询value
-
这个对象，我们称其为值(value)
-
所以字典，也称做键值对(key-value)结构
-
每个字典中都可以有多个键值对，而每一个键值对我们称其为一项(item)
-
# 字典
# 使用{}来创建字典
d = {}
'''
创建一个保护有数据的字典
语法:
{key:value,key:value,key:value}
1.字典的值可以是任意对象
2.字典的键可以是任意的不可变对象(int str bool tuple ...),但一般都会使用str
3.字典的键不能重复，如果出现重复的，后面的会替换前面的
'''
d ={
'name': '陈独秀',
'age': 18,
'gender': '男',
}
# 通过键来获取值
print(d['name'])
2.字典的使用
-
创建字典&获取键值&添加key-value&更新字典中的value
'''
创建字典①
使用{}
语法：{key:value,key:value,key:value}
'''
'''
创建字典②
1.使用dict()函数来创建字典
2.每一个参数都是一个键值对，参数名就是键，参数名就是值（这种方式创建的字典，key都是字符串）
'''
d = dict(name='陈独秀', age=18, gender='男')
'''
创建字典③
1.可以将一个包含双值子序列的序列转换为字典
2.双值序列，序列中只有两个值 [1,2] ('a',3)
3.子序列，如果序列中的元素也是序列，那么我们就称这个元素为子序列；e.g. [(1,2),(3,5)]
'''
d = dict([('name', '风'), ('age', 99)])
print(d, type(d))
# len()获取字典中键值对的个数
print(len(d))
# in 检查字典中是歪包含指定的键
# not in 检查字典中是否不包含指定的键
print('hello' in d)
# 获取字典中的值，根据键来获取值
print(d['name'])
'''
get(key[,default]) 该方法用来根据键来获取字典中的值
如果获取的值在字典中不存在，会返回None，也可以指定一个默认值，
来作为第二个参数，这样获取不到值时将会返回默认值
'''
print(d.get('name'))
print(d.get('hello', '我是默认值'))
# 修改字典
# d[key]=value 如果key存在则覆盖，不存在则添加
d['name'] = 'ke' # 修改字典的key-value
d['address'] = 'gz' # 向字典的key-value
print(d)
'''
setdefault(key[,default])可以用来向字典中添加key-value
如果key已经存在于字典中，则返回key的值，不会对字典做任何操作
如果key不存在，则向字典中添加key，并设置value
'''
exist_key = d.setdefault('name', 'tester')
not_exist_key = d.setdefault('hello', 'tester')
print(not_exist_key)
'''
update([other])
将其他的字典中的key-value添加当前字典中
如果有重复的key，则后边的会替换
'''
d1 = {'a': 1, 'b': 2, 'c': 3}
d2 = {'e': 5, 'f': 6, 'g': 7, 'a': 8}
d1.update(d2)
print(d1)
-
删除&拷贝
# 删除，可以使用del来删除字典中的key-value
d = {
'name': '陈独秀',
'age': 18,
'gender': '男',
}
del d['age']
# popitem()
'''
1.随机删除字典中的一个键值对，一般都会删除最后一个键值对
2.删除之后，它会将删除的key-value作为返回值返回
3.返回的是一个元组，元组中有两个元素，第一个元素是删除的key,第二个元素是删除的value
4.当使用popitem()删除一个空字典时，会抛异常
'''
result = d.popitem()
print(result)
# pop(key[,default])
'''
1.根据key删除字典中的key-value，会将被删除的value返回；
2.如果删除不存在的key,会抛异常
3.如果指定了默认值，再删除不存在的key时，不会报错，而是直接返回默认值
'''
d = {'a': 1, 'b': 2, 'c': 3}
result = d.pop('a')
result = d.pop('a', '这是默认值')
# clear()用来清空字典
d.clear()
# copy()
'''
1.该方法用于对字典进行浅复制
2.复制以后的对象，和原对象是独立，修改一个不会影响另一个
3.浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制
'''
d = {'a': 1, 'b': 2, 'c': 3}
d2 = d.copy()
-
遍历字典
d = {
'name': '陈独秀',
'age': 18,
'gender': '男',
}
# keys(),该方法会返回字典的所有的key
for k in d.keys():
print(k, d[k])
# values(),该方法会返回一个序列，序列中保存有字典的值
for v in d.values():
print(v)
# item()
'''
1.该方法会返回字典中所有的项
2.它会返回一个序列，序列中包含有双值序列
3.双值分别是，字典中的key-value
'''
for k, v in d.items():
print(k, '=', v)
3.集合(set)
-
集合和列表非常相似
-
不同点
-
集合中只能存储不可变对象
-
集合中存储的对象是无序（不是按照元素的插入顺序保存）
-
集合中不能出现重复的元素
-
# 使用{}和来创建集合
s = {10, 3, 5, 1, 2, 1, 1, 1}
# 使用set()函数创建集合
# 空集合
s = set()
# 可以通过set()来将序列和字典转换为集合
translate_list = set([1, 2, 3, 4, 5])
# 使用set()将字典转换为集合时，只会包含字典中的键
translate_dict = set({'a': 1, 'b': 2})
# 使用in和not in来检查集合中的元素
print('c' in translate_dict)
# 使用len()来获取集合中元素的数量
print(len(s))
# add()向集合中添加元素
s.add(25)
# update() 将一个集合中的元素添加到当前集合中
# update()可以传递序列或字典作为参数，字典只会使用键
s2 = set('hello')
s.update(s2)
s.update((10, 50, 60))
s.update({'a': 90})
print(s)
# pop()随机删除并返回一个集合中的元素
s.pop()
# remove()删除集合中的指定元素
s.remove(10)
# clear()清空集合
s.clear()
# copy()对集合进行浅复制
-
集合的运算
# 创建两个集合
s = {1, 2, 3, 4, 5}
s2 = {3, 4, 5, 6, 7}
# 在对集合做运算时，不会影响原来的集合，而是返回一个运算结果
# & 交集运算，返回两个集合的公共部分
result = s & s2
print('result =', result)
# | 并运算，将两个集合合并
result = s | s2
print('result =', result)
# - 差集，返回只在s集合中有，s2集合中无的元素
result = s - s2
print('result =', result)
# ^ 异或集 获取只在一个集合中出现的元素
result = s ^ s2
print('result =', result)
# <= 检查一个集合中是否是另外一个集合的子集
# 如果a集合中的元素全部都在b集合中出现，那么a集合就是b集合的子集，b集合是a集合的超集
a = {1, 2, 3}
b = {1, 2, 3, 4, 5}
# True
result = a <= b
print('result =', result)
# True
result = {1, 2, 3} <= {1, 2, 3}
print('result =', result)
# Fault
result = {1, 2, 3, 4, 5} <= {1, 2, 3}
print('result =', result)
# <检查一个集合是否是另一个集合的真子集
# 如果超集b中含有子集a中所有的元素，并且b中还有a中没有的元素，则b就是a的真超集，a是b的真子集
# Fault
result = {1, 2, 3} < {1, 2, 3}
print('result =', result)
# True
result = {1, 2, 3} < {1, 2, 3, 4, 5}
print('result =', result)
# >= 检查一个集合是否是另一个的超集
# > 检查一个集合是否是另一个的真超集
七、函数(function)
1.函数介绍
-
函数也是一个对象
-
对象是内存中专门用来存储数据的一块区域
-
函数可以用来保存一些可执行的代码，并且可以在需要时，对这些语句进行多次的调用
-
函数中保存的代码不会立即执行，需要调用函数代码都会执行
# 定义一个函数
'''
函数名必须符合标识符的规范（可以包含字母、数字、下划线、但是不能以数字开头）
def 函数名([形参1，形参2，形参3]):
函数体
'''
def fn():
print('我是一个函数')
# 调用函数
# fn是函数对象，fn()是调用函数
#print是函数对象，print()是调用函数
fn()
2.函数的参数
-
在定义函数时，可以在函数后的()定义数量不等的形参
-
形参(形式参数)，定义形参就相当于在函数内部声明了变量，但是并不赋值
-
实参(实际参数)
-
如果函数定义时，指定了形参，那么在调用函数时也必须传递实参，实参将会赋值给对应的形参，简单来说，有几个形参就得有几个实参
-
# 定义一个函数，可以用来任意两个数的和 def sum(a, b): print(a+b) # 调用时传实参 sum(1,5)
-
实参的传递方式
-
位置参数
-
将对应位置的实参复制给对应位置的形参
fn(1, 2, 3)
-
-
关键字参数
-
可以不按照形参定义的顺序去传递，而直接根据参数名去传递参数
fn(b=1, c=2, a=3)
-
-
位置参数和关键字参数可以混合使用，使用时必须将位置参数写到前面
-
-
参数的类型
-
函数在调用时，解析器不会检查实参的类型
-
实参可以传递任意类型的对象
-
def fn(a, b):
print('a =', a)
print('b =', b)
fn('我是字符串', 2)
def fn2(a):
a[0] = 30
'''
在函数中对形参进行重新赋值，不会影响其他的变量
a = 20
a是一个列表时，尝试修改列表中的元素
如果形参执行的是一个对象，当我们通过形参去修改对象时会影响到所有指向该对象的变量
'''
print('a= ', a)
c = [1, 2, 3]
fn2(c)
print('c=', c)
# 如果想不受影响，可以使用copy()或切片的方式，使变量独立
-
不定长参数
# 在定义函数时，可以在形参前边加一个*，这样这个形参将会获取到所有的实参
# 它将会将所有的实参保存到一个元组中
# *a会接受所有的位置实参，并且会将这些实参统一保存到一个元组中（装包）
def fn(*a):
print('a= ', a, type(a))
fn(1, 2, 3, 4)
# 定义一个函数，可以求任意个数字的和
def sum(*nums):
result = 0
# 遍历元组
for num in nums:
result += num
print('求和为：',result)
sum(55, 88, 99, 88)
'''
1.带星号的形参只能有一个
2.带星号的参数，可以和其他参数配合使用
3.第一个参数给a,第二个参数给b，剩下的都保存到c的元组
4.可变参数不是必须写在最后，但是注意，带*的参数后的所有参数，必须以关键字参数的形式传递
'''
def fn2(a, b, *c):
print('a =', a)
print('b =', b)
print('c =', c)
fn2(25, 41, 55, 77, 124, 412, 885)
def fn3(*a, b, c):
print('a =', a)
print('b =', b)
print('c =', c)
fn3(25, 41, 55, 77, 124, b=412, c=885)
# 如果在形参的开头直接写一个*，则要求我们的所有的参数必须以关键字参数的形式传递
def fn4(*, a, b, c):
print('a =', a)
print('b =', b)
print('c =', c)
fn4(a=1, b=2, c=3)
# *形参只能接收位置参数，不能接收关键字参数
# **形参可以接收其他的关键字参数，它会将这些参数统一保存到一个字典中
# 字典的key就是参数的名字，字典的值就是参数的值
# **形参只能有一个，并且必须写在所有参数的最后
def fn5(**a):
print('a=', a, type(a))
fn5(a=1, b='hello', c=True)
#输出结果
a= (1, 2, 3, 4) <class 'tuple'>
330
a = 25
b = 41
c = (55, 77, 124, 412, 885)
a = (25, 41, 55, 77, 124)
b = 412
c = 885
a = 1
b = 2
c = 3
a= {'a': 1, 'b': 'hello', 'c': True} <class 'dict'>
Process finished with exit code 0
3.参数的解包
# 参数的解包
def fn4(a, b, c):
print('a =', a)
print('b =', b)
print('c =', c)
# 创建一个元组
t = (10, 20, 30)
'''
1.传递实参时，也可以在序列类型的参数前添加星号，这样他会自动将序列中的元素依次作为参数传递
2.这里要求序列中元素的个数必须和形参个数一致
'''
fn4(*t)
# 创建一个字典
d = {'a': 100, 'b': 200, 'c': 300}
# 通过 **来对一个字典进行解包操作
fn4(**d)
4.返回值
# 返回值是函数执行以后返回的结果
# 可以通过return来指定函数的返回值
# 可以之间使用函数的返回值，也可以通过一个变量来接收函数的返回值
def sum(*nums):
result = 0
# 遍历元组
for num in nums:
result += num
return result
r = sum(10, 52, 63)
print(r)
# return后边跟什么值，函数就会返回什么值
# return后边可以跟任意的对象，返回值甚至可以是一个函数
# 如果仅仅写一个return 或者不写 return ，则相当于return None
# 在函数中，return后的代码都不会执行
def fn():
print('hello')
return
print('不会执行')
def fn2():
for i in range(5):
# break 用来退出当前循环
# continue 用来跳过当次循环
return #用来结束函数
print(i)
print('循环执行完毕！')
fn2()
def fn3():
return 10
print(fn3) #fn3是函数对象，打印的是函数对象
print(fn3()) #fn3()是调用函数，打印的是返回值
5.文档字符串
# 在定义函数时，可以在函数内部编写文档字符串，文档字符串就是函数的说明 # 当我们编写了文档字符串时，就可以通过help()函数来查看函数的说明 # 文档字符串，直接在函数的第一行写一个字符串就是文档字符串 def fn(a: int, b: bool, c: str): ''' 函数说明信息xxxxxxxxxxxxxx :param a: :param b: :param c: :return: ''' pass
6.作用域(scope)
-
作用域指的是变量生效的区域
-
在python中一共有两种作用域（全局/函数）
-
全局作用域
-
全局作用域在程序执行时创建，在程序执行结束时销毁
-
所有函数以外的区域都是全局作用域
-
在全局作用域中定义的变量，都属于全局变量，全局变量可以在程序的任意位置被访问
-
-
函数作用域
-
函数作用域在函数调用时创建，在调用结束时销毁
-
函数每调用一次就会产生一个新的函数作用域
-
在函数作用域中定义的变量，都是局部变量，它只能在函数内部访问
-
-
变量的查找
-
当使用变量时，会优先在当前作用域中寻找该变量，有则使用
-
如果当前使用域查找不到，则继续往上一级作用域中查找，有则使用，无则继续查找上一级中查找
-
直接找到全局作用域，依然没有找到，则会抛出异常：NameError : name 'xxxx' is not defined
-
-
# 全局变量
a = 20
def fn():
a = 10
print('函数内部：', 'a=', a)
def fn2():
# 在函数中为变量赋值时，默认都是为局部变量赋值
# 如果希望在函数内部修改全局变量，则需要使用global关键字来声明变量
# 声明函数在内部的使用a是全局变量，此时再去修改a时，就是在修改全局的a
global a
a = 10
print('函数内部修改全局变量：', 'a=', a)
fn()
print('函数外部：', 'a=', a)
fn2()
7.命名空间(namespace)
-
命名空间指的是变量存储的位置,每个变量都需要存储到指定的命名空间当中
-
每一个作用域都会有一个它对应的命名空间
-
全局命名空间，用来保存全局变量，函数命名空间用来保存函数中的变量
-
命名空间实际上就是一个字典，是一个专门用来存储变量的字典
-
locals()用来获取当前作用域的命名空间
-
如果在全局作用域中调用locals()则获取全局命名空间，如果在函数作用域中调用locals()则获取函数命名空间，返回的是一个字典
a = 20 # locals()用来获取当前作用域的命名空间 scope = locals() print(type(scope)) def fn(): # globals()函数可以用来在任意位置获取全局命名空间 global_scope = globals()
8.递归
-
递归简单理解就是自己去引用自己
-
递归式函数，在函数中自己调用自己
-
无穷递归，如果这个函数被调用，程序的内存会溢出，效果类似于死循环
-
递归是解决问题的一种方式，它和循环很低，整体思想是将一个大问题分解为一个个小问题，直到问题无法分解时，再去解决问题
-
递归式函数的两个要件
-
基线条件
-
问题可以被分解为最小问题，当满足基线条件时，递归就不在执行
-
-
递归条件
-
将问题继续分解的条件
-
-
'''
1! = 1*1
2! = 2*1!
3! = 3*1!
'''
# 求任意数的阶乘
def factorial(n):
# 基线条件，判断n是否为1，如果为1则此时不能再继续递归
if n == 1:
return 1
# 递归条件
return n * factorial(n-1)
print(factorial(10))
# 判断字符串是不是回文
def hui_wen(s):
# 如果长度小于2，则字符串一定是回文
if len(s) < 2:
return True
# 如果第一个字符不等于最后一个字符，那么一定不是回文
elif s[0] != s[-1]:
return False
# 递归条件
return hui_wen(s[1:-1])
print(hui_wen('abcba'))
9.高阶函数
-
函数式编程
-
在Python中，函数是一等对象
-
一等对象一般都会具有以下特点
-
对象是在运行时创建的
-
能赋值给变量或作为数据结构中的元素
-
能作为参数传递
-
能作为返回值返回
-
-
-
高阶函数
-
高阶函数至少要符合以下两个特点中的一个
-
接收一个或多个函数作为参数
-
将函数作为返回值返回
-
-
# 高阶函数 # 接收函数作为参数，或者将函数作为返回值的函数是高阶函数 # 当我们使用一个函数作为参数时，实际上是将指定的代码传递给目标函数 def even_number(num): if num % 2 != 0: return False return True def uneven_number(num): if num % 2 == 0: return True return False def fn(func, lst): ''' fn()函数可以获取列表中偶数或奇数，进行返回 :return: 返回新列表 ''' new_list = [] # 对列表进行筛选 for n in lst: if func(n): new_list.append(n) return new_list num = [1, 2, 3, 4, 5, 6, 7, 8] print(fn(even_number, num))
-
匿名函数
num = [1, 2, 3, 4, 5, 6, 7, 8] # filter() ''' filter()可以从序列中过滤出符合条件的元素，保存到一个新的序列中 参数： 1.函数，根据该函数来过滤列表（可迭代的结构） 2.需要过滤的序列（可迭代的结构） 返回值： 过滤后的新序列（可迭代的结构） ''' print(list(filter(even_number, num))) ''' even_number是作为一个参数传递进filter()函数中 而fn4实际上只有一个使用，就是作为filter()的参数 filter()调用完毕之后，even_number就已经没用 ''' # 匿名函数 lambda 函数表达式 # lambda函数表达式专门用来创建一些简单的函数，它是函数创建的又一种方式 # 语法： lambda 参数列表 : 返回值 r = filter(lambda i: i % 2 == 0, num) print(list(r)) # map() # map()函数可以对迭代对象中的所有元素做指定的操作，然后将其添加到一个新的对象中返回 l = map(lambda i: i*2, num) print(list(l)) # sort() ''' 该方法用来对列表中的元素进行排序 sort()方法默认是直接比较列表中的排序 在sort()可以接收一个关键字参数[key] key需要一个函数作为参数，当设置了函数作为参数 每次都会以列表中的一个元素作为参数来调用函数，并且使用函数的返回值来比较元素的大小 ''' str_list = ['a', 'bbb', 'ddddd', 'cc', 'eeeee'] str_list.sort(key=len) print(str_list) # sorted() ''' 该函数和sort()的用法基本一致，但是sorted()可以对任意对象的序列进行排序 并且使用sorted()排序不会影响原来的对象，而是返回一个新对象 ''' l = '124587965426345' print(sorted(l))
-
闭包（类似java中的private修饰的[私有变量]）
-
将函数作为返回值返回，也是一种高阶函数
-
这种高阶函数我们也称为闭包，通过闭包可以创建一些只有当前函数能访问的变量
-
可以将一些私有的数据藏到闭中包
-
def fn():
a = 10
# 函数内部再定义一个函数
def inner():
print('我是fn2', a)
# 将内部函数 inner作为返回值返回
return inner
def make_average():
# 创建一个列表，用来保存数值
nums = []
# 创建一个函数，用来计算平均值
def average(n):
nums.append(n)
# 求平均值
return sum(nums) / len(nums)
return average
get_average = make_average()
print(get_average(10))
print(get_average(15))
# 此处nums重新赋值为一个空列表，但不会影响make_average的nums
nums = []
print(get_average(11))
-
装饰器
-
通过装饰器，可以在不修改原来函数的情况下对函数进行扩展
-
在开发中，都是通过装饰器来扩展函数功能
-
在定义函数时，可以通过@装饰器，来使用指定的装饰器，用来装饰当前的函数
-
可以同时为一个函数指定多个装饰器
-
import time def calculate_time(func): # 不定义参数 args元组，kwargs字典 def wrapper(*args, **kwargs): # 扩展部分 start_time = time.time() # 原来的函数部分 result = func(*args, **kwargs) # 扩展部分 end_time = time.time() print(end_time - start_time) return result # 返回函数本身 return wrapper # 使用add函数时，先调用calculate_time，将add()作为参数进行传递 @calculate_time def add(a, b): time.sleep(1) return a + b print(add(1, 58))
八、对象（Object）
1.什么是对象
-
对象是内存中专门用来存储数据的一块区域
-
对象中可以存储各种数据（e.g. 数字、布尔值、代码）
-
对象由三部分组成
-
对象的标识id
-
对象的类型type
-
对象的值value
-
2.面向对象(oop)
-
python是一门面向对象的编程语言
-
所谓的面向对象的语言，简单理解就是语言中的所有操作都是通过对象来进行的
-
面向过程的编程语言
-
面向过程指将我们的程序逻辑分解为一个一个步骤，通过对每个步骤的抽象，来完成程序
-
-
面向对象的编程语言
-
面向对象的编程语言，关注的是对象，而不关注过程
-
对于面向对象的语言来说，一切都是对象
-
面向对象的编程思想，将所有的功能统一保存到对应的对象中
-
这种方式编写的代码，比较容易阅读，并且比较易于维护，容易复用
-
3.类(class)
-
目前所学习的对象都是python内置的对象
-
内置对象并不能满足所有的需求，在开发中经常需要自定义一些对象
-
类，简单理解它就是一张图纸，在程序中我们需要根据类创建对象，类就是对象的图纸，也称为对象是类的实例(instance)
-
如果多个对象是通过一个类创建的，我们称这些对象是一类对象
-
自定义的类都需要使用大写字母开头，使用驼峰命名法
-
类也是一个对象
-
类就是一个用来创建对象的对象
-
类是type类型的对象，定义类实际上就是定义了一个type类型的对象
# 创建一个int类实例
a = int(10)
# 创建一个str类实例
b = str('hello')
# 定义一个简单的类
# 使用class关键字来定义类，语法和函数很像
# class 类名([父类]):
# 代码块
# <class '__main__.MyClass'>
class MyClass():
pass
#print(MyClass)
# 使用MyClass创建一个对象
# 使用类来创建对象，就像调用一个函数一样
# mc是通过MyClass创建的对象，mc是MyClass的实例
mc = MyClass()
mc1 = MyClass()
mc2 = MyClass()
# mc/mc1/mc2都是MyClass的实例，它们都是一类对象
# isinstance()用来检查一个对象是否是一个类的实例
result = isinstance(mc2, MyClass)
result2 = isinstance(mc2, str)
print('result= ', result)
print('result2= ', result2)
#运行结果：
result= True
result2= False
-
对象的创建流程
-
创建一个变量mc
-
在内存中创建一个新对象
-
将对象的id赋值给变量
-
class MyClass(): pass # mc是通过MyClass创建的对象，mc是MyClass的实例 mc = MyClass() mc1 = MyClass() mc2 = MyClass() ''' 现在我们通过MyClass这个类创建的对象都是一个空对象 也就是对象中实际上什么都没有，就相当于是一个空的盒子 可以向对象中添加变量，对象中的变量称为属性 语法：对象.属性名 = 属性值 ''' mc.name = '陈独秀' mc1.name = '皮卡丘' print(mc.name) print(mc1.name)
4.类的定义
-
类和对象都是对现实生活中的事物或程序中内容的抽象
-
实际上所有的事物都由两部分构成
-
数据(属性)
-
行为(方法)
-
-
调用方法，对象.方法名()
-
方法调用和函数调用的区别
-
如果是函数调用，则调用时传几个参数，就会有几个实参
-
若是方法调用，默认传递一个参数，所以方法中至少要定义一个形参
-
# 定义一个表示人的类
class Person:
# 在类的代码块中，可以定义变量和函数
# 在类中所定义的变量，将会成为所有实例的公共属性
# 所有实例都可以访问这些变量
name = 'wgf'
# 在类中也可以定义函数，类中定义的函数，我们称为方法
# 这些方法可以通过该类的所有实例来访问
def say_hello(self):
print('hello!')
# 创建Person的实例
p1 = Person()
p2 = Person()
# 调用方法，对象.方法名()
p2.say_hello()
print(p1.name)
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
