python基础语法_python obj

python基础语法笔记

---

一、Python简介

1、python是跨平台的计算机程序设计语言
2、与Java不同的是python没有编译环节
3、python是面向对象的语言
4、python是一种交互式的语言，可以在提示符>>>后直接执行代码

二、Python的基础语法

第一章

1.1 print()函数

#可以输出数字
print(520)
print(98.5)

#可以输出字符串
print('hello world')  #在Python中使用单引号或双引号是没有区别的
print("hello world")  #单双引号的使用可以减少单双引号转义字符的使用

#含有运算符的表达式
print(3+1)

#将数据输出到文件当中,注意点：1、所指定的盘要存在，2、使用file=fp 否则数据没法写入文件
fp=open('D:/text.text','a+')  #如果文件不存在就创建，存在就在文件的内容后面继续追加
print('hello world',file=fp)
fp.close()

#不进行换行输出（输出内容在一行中）
print('hello',' world','python')#这个不会在文件中输出

输出
520
98.5
hello world
hello world
4
hello  world python
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.2 转义字符

当字符串中包含反斜杠、单引号和双引号等有特殊作用的字符时，必须使用反斜杠对这些字符进行转义。

print('hello\nworld')
print('hello\tworld')
print('hello\rworld') #world将hello进行了覆盖
print('hello\bworld') #退一个格，把o退没了

print('http:\\\\www.baidu.com')
print('老师说\'大家好\'')

#原字符，不希望字符串中的转义字符起作用，就使用原字符，在字符串前加上r或R
print(r'hello\nworld')
#注意事项，最后一个字符不能是反斜杠
#print(r'hello\nworld\') 这种情况会报错
print(r'hello\nworld\\') #这种没问题

输出
hello
world
hello	world
world
hellworld
http:\\www.baidu.com
老师说'大家好'
hello\nworld
hello\nworld\\
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

第二章 数据类型

2.1 python中的标识符与保留字

2.1.1 保留字

与关键字意思差不多，不能作为你的对象的名字

#查看所有关键字
import keyword
print(keyword.kwlist)
1
2
3
'
运行
运行

2.1.2 标识符

给变量、函数、类、模块和其它对象起的名字就叫标识符 规则：
1、字母、数字、下划线
2、不能以数字开头
3、不能是保留字
4、区分大小写

2.2 python中的变量与数据类型

变量由三部分组成
1、标识：表示对象所存储的内存地址，使用内置函数id(obj)来获取
2、类型：表示的是对象的数据类型，使用内置函数type(obj)来获取
3、值：表示对象所存储的具体数据，使用print()可以将值进行打印输出

当多次赋值之后，变量名会指向新的空间(新的id)

2.2.1 变量

name='玛丽亚'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)

输出
玛丽亚
标识 2267853848624
类型 <class 'str'>
值 玛丽亚

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

常用的数据类型：整型 int、浮点型 float、布尔型 bool、字符串型 str

2.2.2 整型

n1=90
n2=-90
n3=0
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))

#整数可以表示成二进制、八进制、十进制
print('十进制',118)
print('二进制',0b10101111)
print('八进制',0o176)
print('十六进制',0x1EAF)

输出

90 <class 'int'>
-90 <class 'int'>
0 <class 'int'>
十进制 118
二进制 175
八进制 126
十六进制 7855
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.2.3 浮点型

a=3.14159
print(a,type(a))
n1=1.1
n2=2.2
n3=2.1
print(n1+n2) #使用浮点数进行计算时，可能会出现小数位数不确定的情况
print(n1+n3)

from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))

输出
3.14159 <class 'float'>
3.3000000000000003
3.2
3.3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.2.4 布尔型

f1=True
f2=False
print(f1,type(f1))
print(f2,type(f2))

#布尔值可以转换成整数计算
print(f1+1) #2  1+1的结果是2 True表示1
print(f2+1) #1  0+1的结果为1 False表示0

输出
True <class 'bool'>
False <class 'bool'>
2
1
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.2.5 字符串型

⚪单引号和双引号定义的字符串必须在一行
⚪三引号定义的字符串可以连续分布在多行

str1='人生苦短，我用python'
str2="人生苦短，我用python"
str3="""人生苦短，
我用python"""
str4='''人生苦短，
我用python'''
print(str1,type(str1))
print(str2,type(str2))
print(str3,type(str3))
print(str4,type(str4))

输出
人生苦短，我用python <class 'str'>
人生苦短，我用python <class 'str'>
人生苦短，
我用python <class 'str'>
人生苦短，
我用python <class 'str'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.2.6 数据类型转换

2.2.6.1 str()函数

将int型通过str()函数转成str型，同理其它类型也可通过此函数进行转换

name='张三'
age=20

print(type(name),type(age)) #name与age的数据类型不同
 # print('我叫'+name+'今年'+age+'岁')  
 #会报错，name和age的数据类型不同
print('我叫'+name+',今年'+str(age)+'岁')

输出
<class 'str'> <class 'int'>
我叫张三,今年20岁
1
2
3
4
5
6
7
8
9
10
11

2.2.6.2 int()函数

⚪文字类和小数类字符串无法转换成整数
⚪浮点数转换成整数，抹零取整

s1='128'
f1=98.7
s2='76.77'
ff=True
s3='hello'
print(type(s1),type(f1),type(s2),type(ff),type(s3))
print(int(s1),type(int(s1))) #将str转换成int类型，字符串为数字串
print(int(f1),type(int(f1))) #将float转换成int类型，舍弃小数
 #  print(int(s2),type(int(s2))) 会报错 小数串
print(int(ff),type(int(ff)))
 #  print(int(s3),type(int(s3))) 会报错 必须为数字串

输出
<class 'str'> <class 'float'> <class 'str'> <class 'bool'> <class 'str'>
128 <class 'int'>
98 <class 'int'>
1 <class 'int'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.2.6.3 float()函数

⚪文字类无法转换
⚪整数转换后末尾加上.0

s1='128.98'
s2='76'
ff=True
s3='hello'
i=98
print(type(s1),type(s2),type(ff),type(s3),type(i))
print(float(s1),type(float(s1)))
print(float(s2),type(float(s2)))
print(float(ff),type(float(ff)))
 #print(float(s3),type(float(s3))) 报错
print(float(i),type(float(i)))

输出
<class 'str'> <class 'str'> <class 'bool'> <class 'str'> <class 'int'>
128.98 <class 'float'>
76.0 <class 'float'>
1.0 <class 'float'>
98.0 <class 'float'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.3 python中的注释

⚪单行注释：以#开头
⚪多行注释：一对三引号之间的代码称为多行注释
⚪三引号若赋值给变量，则认为是字符串，否则是多行注释）

第三章 运算符

3.1 输入函数input

⚪作用：接收来自用户的输入
⚪返回值类型：输入值的类型为str
⚪值的存储：使用=对输入的值进行存储

present=input('大圣想要什么礼物呢?\n') #使input函数之后需要用户在键盘输入
print(present,type(present))

输出
大圣想要什么礼物呢?
金箍棒
金箍棒 <class 'str'>
1
2
3
4
5
6
7

3.2 python中的运算符

3.2.1 算术运算符

加(+)、减(-)、乘()、除(/)、整除(//)、取余(%)、幂运算符(**)

print(11//2) #抹去小数点
print((11//(-3))) #一正一负向下取整
print(2**3) #表示的是2的3次方
print(-9%4) #余数=被除数-除数*商 余数=-9-4*(-3)=3 商是向下取整

输出
5
-4
8
3
1
2
3
4
5
6
7
8
9
10

3.2.2 赋值运算符

执行顺序：从右往左
支持链式赋值：a=b=c=20
支持参数赋值：+=、-=、*=、/=、//=、%=
支持系列解包赋值：a,b,c=20,30,40

a=b=c=20
print(a,id(a))
print(b,id(b))
print(c,id(c))

a,b=20,20.1
print(type(a),type(b))
a,b=b,a
print(a,b)

输出
20 140727499999488
20 140727499999488
20 140727499999488
<class 'int'> <class 'float'>
20.1 20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.2.3 比较运算符

比较运算符的结果是bool型

a,b=10,20
print('a>b吗',a>b)  #比较运算符的结果为bool型

输出
a>b吗 False
1
2
3
4
5

3.2.4 布尔运算符

and、or、not、in、not in

a,b=1,2
print(a==1 and b==2)
print(a==1 and b<2)
print(not a)

s='hello'
print('k' in s)

输出
True
False
False
False
1
2
3
4
5
6
7
8
9
10
11
12
13

3.2.5 位运算符

print(2 & 2) #十进制转为八位二进制，按位与，
print(2 & 1)
print(4 | 8) #十进制转为八位二进制，按位或
print(4 << 2) #十进制转为八位二进制，左移两位

输出
2
0
12
16
1
2
3
4
5
6
7
8
9
10

3.3 运算符的优先级

算术运算符>位运算符>比较运算符>布尔运算符>赋值运算符

第四章 组织结构

4.1 程序的组织结构

计算机的流程控制 1、顺序结构 2、选择结构 3、循环结构

4.2 顺序结构

添加断点，对程序进行调试

4.3 对象的布尔值

⚪获取对象的布尔值使用内置函数bool()
⚪以下对象的布尔值为False：False、0、None、空字符串、空列表、空元组、空字典、空集合

4.4 分支结构

4.4.1 单分支if结构

money=1000
s=int(input('请输入取款金额'))
if money>=s:
    money-=s
    print('取款成功，余额为：',money)
    
输出
请输入取款金额100
取款成功，余额为： 900
1
2
3
4
5
6
7
8
9

4.4.2 双分支if…else结构

s=int(input('请输入一个整数'))
if s%2==0:
    print(s,'是偶数')
else:
    print(s,'是奇数')
    
输出
请输入一个整数5
5 是奇数
1
2
3
4
5
6
7
8
9

⚪另有条件判断语句
⚪正确就执行if左边的语句，错误就执行else右边的语句

a,b=10,20
print(str(a)+'大于'+str(b) if a>b else str(a)+'小于'+str(b))

输出
10小于20
1
2
3
4
5

4.4.3 多分支if…elif…else结构

score=int(input('请输入成绩：'))
if score>90:
    print('A级')
elif score>60 and score<=90:
    print('B级')
else:
    print('C级')
    
输出
请输入成绩：55
C级
1
2
3
4
5
6
7
8
9
10
11

4.5 pass空语句

⚪语句什么都不做，知识一个占位符，用在语法上需要语句的地方
⚪使用情况：先搭建语法结构，还没想好代码怎么写的时候

answer=input('您是会员吗？y/n')
if answer=='y':
    pass
else:
    pass

输出
您是会员吗？y/n y

进程已结束,退出代码0
1
2
3
4
5
6
7
8
9
10

第五章 循环

5.1 range()函数的使用

⚪用于生成一个整数序列
⚪创建range对象的三种方式
1、range(stop) 创建一个(0,stop)之间的整数序列，步长为1
2、range(start,stop) 创建一个(start,stop)之间的整数序列，步长为1
3、range(start,stop,step) 创建一个(start,stop)之间的整数序列，步长为step

r=range(10)     
print(r)        
print(list(r))  
                
r2=range(2,5)   
print(list(r2)) 
                
r3=range(3,10,2)
print(list(r3)) 

输出
range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 3, 4]
[3, 5, 7, 9]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5.2 while循环

a=1
while a<5:
    print(a)
    a+=1
 
输出
1
2
3
4
1
2
3
4
5
6
7
8
9
10

5.3 for-in循环

in表示从(字符串、序列等)中依次取值，又称为遍历

for item in range(5):  #将in后的序列依次赋值给for后的对象
    print(item)  
#如果用不到自定义变量，可将自定义变量写为"_"  
    
输出
0
1
2
3
4
1
2
3
4
5
6
7
8
9
10

5.4 break、continue、else语句

break、continue与其它语言用法一样，就不进行描述了。

for item in range(3):
    pwd=input('请输入密码\n')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码错误')
else:            #当for循环正常循环结束时，执行此else语句
    print('对不起，三次密码均错误')
    
 输出
请输入密码
111
密码错误
请输入密码
222
密码错误
请输入密码
333
密码错误
对不起，三次密码均错误
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

5.5 嵌套循环

内容重复，不过多概述
需注意，内层循环中的break和continue只用于控制本层循环

第六章 列表

6.1 列表的创建和删除

#列表的创建，第一种方式，使用中括号[]
lst1=['hello','world',123]
print(lst1)

#列表的创建，第二种方式，使用内置函数list()
lst2=list(['hello','world',123])
print(lst2[-3])  #从左往右0开始，从右往左-1开始

输出
['hello', 'world', 123]
hello
1
2
3
4
5
6
7
8
9
10
11

6.2 列表的查询操作

lst=['hello','world','hello',123]
print(lst.index('hello'))  #如果列表中有相同元素，只返回第一个元素的位置
print(lst.index('hello',1,3)) #限定查找位置

输出
0
2
1
2
3
4
5
6
7

lst=[10,20,30,40,50,60,70,80]
print(lst[1:6:1])   #获取列表中的多个元素 列表名[start:stop:step]  [start,stop)

print(lst[-1:-3:-1]) #step是负数表示从后往前开始 最后一个为-1

输出
[20, 30, 40, 50, 60]
[80, 70]
1
2
3
4
5
6
7
8

6.3 列表元素的增删改操作

6.3.1 增

6.3.1.1 append()函数

在列表的末尾添加一个元素，一次只能添加一个

lst=[10,20,30]
lst.append(100)
print(lst)

输出
[10, 20, 30, 100]
1
2
3
4
5
6

6.3.1.2 extend()函数

在列表的末尾至少添加一个元素

lst1=[10,20,30]
lst2=[10,20,30]
lst1.extend(lst2)
print(lst1)
lst1.append(lst2)
print(lst1)

输出
[10, 20, 30, 10, 20, 30]
[10, 20, 30, 10, 20, 30, [10, 20, 30]]
1
2
3
4
5
6
7
8
9
10

6.3.1.3 insert()函数

在列表的任意位置添加一个元素

lst=[10,20]
lst.insert(2,30) #在第二个位置上插入元素，第二个位置及其之后的元素后移
print(lst)

输出
[10, 20, 30]
1
2
3
4
5
6

6.3.1.4 切片

在列表的任意位置添加至少一个元素

lst=[10,20,30,40]
new_lst=['hello']
lst[1:3]=new_lst
print(lst)

输出
[10, 'hello', 40]
1
2
3
4
5
6
7

6.3.2 删

6.3.2.1 remove()函数

⚪一次删除一个元素
⚪重复的元素只删除第一个

lst=[10,20,30,40,30]
lst.remove(30)
print(lst)

输出
[10, 20, 40, 30]
1
2
3
4
5
6

6.3.2.2 pop()函数

⚪删除一个指定位置上的元素
⚪不指定索引，删除列表中最后一个元素

lst=[10,20,30,40,30]
lst.pop(1)
lst.pop() #不指定则删除最后一个元素
print(lst)

输出
[10, 30, 40]
1
2
3
4
5
6
7

6.3.2.3 切片

一次最少删除一个元素

lst=[10,20,30,40]
new_lst=lst[1:3]
print(lst,new_lst)
lst[1:3]=[]
print(lst)

输出
[10, 20, 30, 40] [20, 30]
[10,40]
1
2
3
4
5
6
7
8
9

6.3.2.4 clear()函数

清空列表

lst=[10,20,30]
lst.clear()
print(lst)

输出
[]
1
2
3
4
5
6

6.3.2.5 del

删除列表

lst=[10,20,30]
del lst
1
2
'
运行
运行

6.3.3 改

6.3.3.1 为指定索引赋值

lst=[10,20,30,40]
lst[1]=100
print(lst)

输出
[10, 100, 30, 40]
1
2
3
4
5
6

6.3.3.2 为指定切片赋值

lst=[10,20,30,40]
lst[1:3]=100,200
print(lst)

输出
[10, 100, 200, 40]
1
2
3
4
5
6

6.4 列表元素的排序

6.4.1 调用sort()方法

⚪列表中所有元素默认按照从小到大的顺序进行排序
⚪可以指定revers=True进行降序排序

lst=[10,30,20,40]
lst.sort()
print(lst)
lst.sort(reverse=True)
print(lst)

输出
[10, 20, 30, 40]
[40, 30, 20, 10]
1
2
3
4
5
6
7
8
9

6.4.2 调用内置函数sorted()

⚪调用内置函数sorted()
⚪可以指定revers=True进行降序排序，原列表不发生改变(生成新的对象)

lst=[10,30,20,40]
new_lst=sorted(lst)
print(new_lst)
desc_lst=sorted(lst,reverse=True)
print(desc_lst)

输出
[10, 20, 30, 40]
[40, 30, 20, 10]
1
2
3
4
5
6
7
8
9

6.5 列表生成式

lst1=[i for i in range(1,10)]
print(lst1)
lst2=[i*2 for i in range(1,6)]
print(lst2)

输出
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 4, 6, 8, 10]
1
2
3
4
5
6
7
8

第七章 字典

7.1 什么是字典

⚪字典是python内置的数据结构之一，与列表一样是一个可变序列
⚪以键值对的方式存储数据，字典是一个无序的序列

scores={ ' 张三 ' : 90 , ' 李四 ' : 98 , ' 王五 ' : 45 }
1
'
运行
运行

字典的特点 ：
字典中的所有元素都是一个键值对，键不允许重复，值可以重复
字典中的元素是无序的
字典中的键必须是不可变对象
字典可以根据需要动态的伸缩
字典会浪费较大的内存，使用空间换时间的数据结构

7.2 字典的原理

哈希存储，根据key查找value所在的位置

7.3 字典的创建与删除

7.3.1 字典的创建

#使用花括号{}创建字典
scores={ ' 张三 ' : 90 , ' 李四 ' : 98 , ' 王五 ' : 45 }
print(scores)

#使用内置函数 dict()创建字典
student=dict(name='张三',scores=99)
print(student)

输出
{' 张三 ': 90, ' 李四 ': 98, ' 王五 ': 45}
{'name': '张三', 'scores': 99}
1
2
3
4
5
6
7
8
9
10
11

7.3.2 字典的删除

7.4 字典的查询操作

7.4.1 普通

#使用scores[]方式
scores={ ' 张三 ' : 90 , ' 李四 ' : 98 , ' 王五 ' : 45 }
print(scores[' 张三 '])

#使用get()方法
print(scores.get(' 张三 '))

#注意
print(scores.get(' 陈六 ')) #none
print(scores.get(' 麻七 ',99))  #查找麻七不存在时，提供的默认值99

输出
90
90
None
99
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

7.4.2 进阶

lst=[
    {'rating':[9.7,50],'id':111,'type':'犯罪','title':'肖申克的救赎','actors':['蒂姆','摩根']},
    {'rating':[9.6,50],'id':222,'type':'爱情','title':'霸王别姬','actors':['张国荣','张丰毅']},
    {'rating':[9.5,50],'id':333,'type':'悬疑','title':'控方证人','actors':['泰隆','马琳']}
     ]

name=input('请输入你想查询的演员：')
for item in lst:
    act_list=item['actors']
    for actor in act_list:
        if name in actor:
            print(name,'出演了',item['title'])

输出
请输入你想查询的演员：张国荣
张国荣 出演了 霸王别姬
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

7.5 字典元素的增删改操作

7.5.1 key的判断

判断指定的key在字典中是否存在，使用in或not in

scores={ ' 张三 ' : 90 , ' 李四 ' : 98 , ' 王五 ' : 45 }
print(' 张三 ' in scores)
print(' 张三 ' not in scores)

输出
True
False
1
2
3
4
5
6
7

7.5.2 字典元素的删除

scores={ ' 张三 ' : 90 , ' 李四 ' : 98 , ' 王五 ' : 45 }
del scores[' 张三 ']
print(scores)

scores.clear()
print(scores)

输出
{' 李四 ': 98, ' 王五 ': 45}
{}
1
2
3
4
5
6
7
8
9
10

7.5.3 字典元素的新增

scores={ ' 张三 ' : 90 , ' 李四 ' : 98 , ' 王五 ' : 45 }
scores.clear()
print(scores)

scores['陈六']=98
print(scores)

输出
{}
{'陈六': 98}
1
2
3
4
5
6
7
8
9
10

7.5.4 字典元素的修改

scores={ ' 张三 ' : 90 , ' 李四 ' : 98 , ' 王五 ' : 45 }
scores.clear()
print(scores)

scores['陈六']=98
print(scores)

scores['陈六']=100
print(scores)

输出
{}
{'陈六': 98}
{'陈六': 100}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

7.6 字典推导式

7.7 字典的其它操作

7.7.1 获取字典视图的三个方法

scores={ ' 张三 ' : 90 , ' 李四 ' : 98 , ' 王五 ' : 45 }
keys=scores.keys()
print(keys)
print(list(keys)) #将所有的key组成的视图转成列表

values=scores.values()
print(values)
print(list(values))

items=scores.items()
print(items)
print(list(items))

输出
dict_keys([' 张三 ', ' 李四 ', ' 王五 '])
[' 张三 ', ' 李四 ', ' 王五 ']
dict_values([90, 98, 45])
[90, 98, 45]
dict_items([(' 张三 ', 90), (' 李四 ', 98), (' 王五 ', 45)])
[(' 张三 ', 90), (' 李四 ', 98), (' 王五 ', 45)]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

7.7.2 字典元素的遍历

scores={'张三':90,'李四':98,'王五':45}
for item in scores:  #遍历键
    print(item,scores[item],scores.get(item))
    
输出
张三 90 90
李四 98 98
王五 45 45
1
2
3
4
5
6
7
8

第八章 元组与集合

8.1 什么是元组

元组是python内置数据结构之一，是一个不可变序列

⚪不可变序列：字符串，元组 没有增删改的操作
⚪可变序列：列表，字典 可以增删改，对象地址不发生改变

8.2 元组的创建方式

#直接使用小括号
t=('python','word',98)
print(t)

#使用内置函数tuple()
t2=tuple(('hello','word',99))
print(t2)

t3='hello',23
print(tuple(t3))

#只包含一个元素需要使用逗号，
t4=('hello')
print(type(t4))
t5=('hello',)
print(type(t5),t5)

输出
('python', 'word', 98)
('hello', 'word', 99)
('hello', 23)
<class 'str'>
<class 'tuple'> ('hello',)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

8.3 元组的遍历

t=tuple(('python','world',99))
print(t)
for item in t:
    print(item)
    
输出
('python', 'world', 99)
python
world
99
1
2
3
4
5
6
7
8
9
10

8.4 什么是集合

⚪python提供的内置数据结构
⚪与列表、字典一样都是可变类型的序列
⚪集合是没有value的字典

8.5 集合的创建

#使用{}创建集合
s={'hello','word',8,8}  #集合中的元素不能重复，且无序
print(s)

#使用内置函数set()创建集合
s1=set(range(6))
print(s1,type(s1))

s2=set([1,2,3,4,5]) #将列表转换为集合
print(s2,type(s2))
	
s3=set((1,2,3,4)) #将元组转换为集合
print(s3,type(s3))
	
s4=set('python') #将字符串转换为集合
print(s4,type(s4))

#创建空集合
s7=set()

	输出
	{8, 'hello', 'word'}
	{0, 1, 2, 3, 4, 5} <class 'set'>
	{1, 2, 3, 4, 5} <class 'set'>
	{1, 2, 3, 4} <class 'set'>
	{'o', 'n', 'p', 'h', 'y', 't'} <class 'set'>
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

8.6 集合的增删改查操作

8.6.1 集合元素的判断操作

s={10,20,30,40,50}
print(60 in s)
print(60 not in s)

输出
False
True
1
2
3
4
5
6
7

8.6.2 集合元素的新增操作

s={10,20,30,40,50}
s.add(60)   #一次添加一个元素
print(s)
t={70,80}
s.update(t)
print(s)
s.update(['hello']) #一次至少添加一个元素
print(s)

输出
{40, 10, 50, 20, 60, 30}
{70, 40, 10, 80, 50, 20, 60, 30}
{'hello', 70, 40, 10, 80, 50, 20, 60, 30}
1
2
3
4
5
6
7
8
9
10
11
12
13

8.6.3 集合元素的删除操作

s={10,20,30,40,50}
s.remove(30)  #一次移除一个元素，不存在这个元素则报错
print(s)

s.discard(500)
print(s)     #一次移除一个元素，元素不存在不报错

s.pop()
print(s)    #一次随机删除一个元素

s.clear()
print(s)    #清空集合

输出
{40, 10, 50, 20}
{40, 10, 50, 20}
{10, 50, 20}
set()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

8.7 集合生成式

8.8 集合间的关系

相等、子集、超集、交集

s1={10,20,30,40}
s2={30,40,50,60}
s3={10,20}

print(s1!=s2) #判断集合相等（元素相同就相等）

print(s3.issubset(s1)) #s3是否是s1的子集
print(s2.issubset(s1))  #s2是否是s1的子集

print(s1.issuperset(s3))  #s1是否是s3的超集
print(s1.issuperset(s2))   #s1是否是s2的超集

print(s1.isdisjoint(s2))   #判断是否有交集，有交集就是false
print(s2.isdisjoint(s3))   #没有交集就是true

输出
True
True
False
True
False
False
True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

第九章 字符串

9.1 字符串的创建与驻留机制

字符串的驻留机制：python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同的字符串不会开辟新的空间。

a='python'
b="python"
c="python"

print(a,id(a))
print(a,id(b))
print(a,id(c))

输出
python 2715141037744 #每个地址都一样
python 2715141037744
python 2715141037744
1
2
3
4
5
6
7
8
9
10
11
12

9.2 字符串的常用操作

9.2.1 字符串的查询操作

index() 查找子串第一次出现的位置，若子串不存在，则抛出ValueError
rindex() 查找子串最后一次出现的位置，若子串不存在，则抛出ValueError
find() 查找子串第一次出现的位置，若子串不存在，则返回-1
rfind() 查找子串最后一次出现的位置，若子串不存在，则返回-1

s='hello,hello'
print(s.index('lo'))
print(s.rindex('lo'))
print(s.find('lo'))
print(s.rfind('lo'))
print(s.find('k'))

输出
3
9
3
9
-1
1
2
3
4
5
6
7
8
9
10
11
12
13

9.2.2 字符串的大小写转换操作

upper() 把字符串中所有的字符都转换成大写字母
lower() 把字符串中所有的字符都转换成小写字母
swapcase() 字符串中的所有字符大写转小写，小写转大写
capitalize() 字符串中的第一个字符大写，其余小写
title() 把每个单词的第一个字符转为大写

s='heLLo,pyTHon'
a=s.upper()
print(a)
print(s.lower())
print(s.swapcase())
print(s.title())
print(s.capitalize())

输出
HELLO,PYTHON
hello,python
HEllO,PYthON
Hello,Python
Hello,python
1
2
3
4
5
6
7
8
9
10
11
12
13
14

9.2.3 字符串的内容对齐操作

⚪center() ：居中对齐，第一个参数指定宽度，第二个参数指定填充字符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
⚪ljust() ：左对齐，第一个参数指定宽度，第二个参数指定填充字符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
⚪rjust() ：右对齐，第一个参数指定宽度，第二个参数指定填充字符，第二个参数是可选的，默认是空格，如果设置宽度小于实际宽度则返回原字符串
⚪zfill() ：右对齐，左边用0填充，该方法直接收一个参数，用于指定字符串的宽度，如果指定的宽度小于等于字符串的长度，返回字符串本身

s='hello python'
print(s.center(20,'#'))
print(s.ljust(20,'*'))
print(s.rjust(30,'$'))
print(s.rjust(30))
print(s.zfill(40))

输出
####hello python####
hello python********
$$$$$$$$$$$$$$$$$$hello python
                  hello python
0000000000000000000000000000hello python
1
2
3
4
5
6
7
8
9
10
11
12
13

9.2.4 字符串劈分操作的方法

⚪split() ：从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
⚪通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独作为一部份
⚪以通过参数sep指定劈分字符串是的劈分符

⚪rsplit() ：从字符串的右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表
⚪通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串会单独作为一部份
以通过参数sep指定劈分字符串是的劈分符

s='hello python'
lst=s.split()   #默认的劈分符是空格
print(lst)

s1='hello|word|python'
lst1=s1.split(sep='|') 
print(lst1)

s2='hello|word|python'
print(s2.split(sep='|',maxsplit=1))

输出
['hello', 'python']
['hello', 'word', 'python']
['hello', 'word|python']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

9.2.5 判断字符串操作的方法

isidentifier() ：判断指定的字符串是不是合法的标识符
isspace() ：判断指定的字符串是否全部由空白字符组成(回车、换行、水平制表符)
isalpha() ：判断指定的字符串是否全部由字母组成
isdecimal() ：判断指定的字符串是否全部由十进制的数组成
isnumerric() ：判断指定的字符串是否全部由数字组成
isalnum() ：判断指定的字符串是否全部由字母和数字组成

s='hello,python'
print(s.isidentifier())
print('hello'.isidentifier())
print(s.isspace())
print(' '.isspace())
print(s.isalpha())
print('abc'.isalpha())
print(s.isdecimal())
print('123'.isdecimal())
print(s.isnumeric())
print(s.isalnum())

输出
False
True
False
True
False
True
False
True
False
False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

9.2.6 字符串的替换与合并操作

⚪replace() ：第一个参数指定被替换的子串，第二个参数指定替换子串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发生变化，调用该方法时可以通过第三个参数指定最大替换次数
⚪join() ：将列表或元组中的字符串合并成一个字符串

s='hello,python'
print(s.replace('python','java'))
s1='hello,python,python,python'
print(s1.replace('python','java',2))

lst=['hello','java','python']
print('|'.join(lst))
print(''.join(lst))

print('*'.join('python'))

输出
hello,java
hello,java,java,python
hello|java|python
hellojavapython
p*y*t*h*o*n
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

9.2.7 字符串的比较操作

运算符：>,>=,<,<=,==,!=

⚪比较规则：首先比较字符串的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串是比较结果，两个字符串中的后续字符将不再被比较

print('apple'>'app')
print('apple'>'banana')
print(ord('a'),ord('b'))

print(chr(97),chr(98))

'''
==与is的区别
==比较的是value
is比较的是id是否相等
'''

输出
True
False
97 98
a b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

9.2.8 字符串的切片操作

字符串是不可变类型，不具备增删改等操作，切片操作将产生新的对象

s='hello,python'
s1=s[:5]    #没有指定起始位置，所以从零开始
s2=s[6:]    #没有指定结束位置，所以切到字符串的最后  #左闭右开
s3='!'
newstr=s1+s2+s3

print(s1)
print(s2)
print(newstr)

print(s[1:5:1]) #从1开始截到5之前，不包括5   s[start:stop:step]
print(s[::2])
print(s[::-1]) #默认从字符串的最后一个元素开始，到字符串的第一个元素结束，因为步长为负数
print(s[-6::1])

输出
hello
python
hellopython!
ello
hlopto
nohtyp,olleh
python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

9.2.9 格式化字符串

name='李四'
age=20

# % 做占位符
print('姓名:%s,年龄：%d'%(name,age))

# {} 做占位符
print('我叫{0}，今年{1}岁'.format(name,age))

#f-string
print(f'我叫{name}，今年{age}岁了')

print('%10d'%99)  #10表示的是宽度
print('%.3f'%3.1415)   #.3表示保留三位小数

print('{0:.3}'.format(3.14159))  #:.3表示保留三位数
print('{0:10.3f}'.format(3.1415))   #:.3f表示保留三位小数

输出
姓名:李四,年龄：20
我叫李四，今年20岁
我叫李四，今年20岁了
        99
3.142
3.14
     3.142
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

第十章 函数

10.1 函数的创建和调用

10.1.1 函数的创建

def 函数名 ( [输入参数] )：
         函数体
         [ return xxx ]
1
2
3

10.1.2 函数的调用

def calc(a,b):
    c=a+b
    return c

result=calc(1,2)
print(result)

输出
3
1
2
3
4
5
6
7
8
9

10.2 函数的参数传递

def calc(a,b):    #a,b为形式参数
    c=a+b
    return c

result=calc(1,2)   #1和2为实际参数
print(result)

res=calc(b=2,a=1)   #关键字参数不按顺序传递参数
print(res)

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

def fun(arg1,arg2):
    print('arg1=',arg1)
    print('arg2=',arg2)
    arg1=100
    arg2.append(10)
    print('arg1',arg1)
    print('arg2',arg2)

n1=11
n2=[22,33,44]
print('n1',n1)
print('n2',n2)
fun(n1,n2)
print('n1',n1)
print('n2',n2)
'''在函数调用过程中，进行参数的传递
如果是不可变的对象，在函数体的修改不会影响实参的值，arg1的修改为100，不会影响n1的值
如果是可变对象，在函数体的修改会影响实参的值，arg2的修改，append(10)，会影响到n2的值
'''

输出
n1 11
n2 [22, 33, 44]
arg1= 11
arg2= [22, 33, 44]
arg1 100
arg2 [22, 33, 44, 10]
n1 11
n2 [22, 33, 44, 10]
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

10.3 函数的返回值

函数返回多个值时，结果为元组

def fun(num):
    odd=[]
    even=[]
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even

lst=[10,11,12,13,14,15,16]
print(fun(lst))

输出
([11, 13, 15], [10, 12, 14, 16])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

10.4 函数的参数定义

10.4.1 默认值参数

函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参

def fun(a,b=10):  #b称为默认值参数
    print(a,b)

fun(100)
fun(10,20)  #b与默认值不符，传递实参

输出
100 10
10 20
1
2
3
4
5
6
7
8
9

10.4.2 个数可变的位置参数

⚪定义函数时，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数。
⚪使用*定义个数可变的位置形参，结果为一个元组

def fun(*args):
    print(args)

fun(10)
fun(10,30)
fun(30,80,110)

输出
(10,)
(10, 30)
(30, 80, 110)
1
2
3
4
5
6
7
8
9
10
11

10.4.3 个数可变的关键字形参

⚪定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参。
⚪使用**定义个数可变的关键字形参，结果为一个字典

def fun(**args):
    print(args)

fun(a=10)
fun(a=20,b=30,c=40)

输出
{'a': 10}
{'a': 20, 'b': 30, 'c': 40}
1
2
3
4
5
6
7
8
9

在一个函数定义的过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求，个数可变的位置形参放在个数可变的关键字形参之前

10.5 变量的作用域

⚪局部变量：在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会生成全局变量
⚪全局变量：函数体外定义的变量，可作用于函数体外

def fun():
    global age
    age=20
    print(age)

fun()    
print(age)   #需先调用一下函数
输出
20
20
1
2
3
4
5
6
7
8
9
10

10.6 递归函数

def fac(n):
    if n==1:
        return 1
    else:
        return n*fac(n-1)
    
print(fac(6))

输出
720
1
2
3
4
5
6
7
8
9
10

第十一章 BUG

11.1 异常的常见类型

语法错误：SyntaxError

age=input('请输入你的年龄')
if int(age)>=18  #没加冒号
    print('成年人应该负法律责任了')

输出
    if int(age)>=18
                  ^
SyntaxError: invalid syntax
1
2
3
4
5
6
7
8

索引越界错误：IndexError

lst=[11,22,33,44]
print(lst[4])   #索引越界

输出
    print(lst[4])
IndexError: list index out of range
1
2
3
4
5
6

除(或取模)零(所有数据类型)：ZeroDivisionError

a = 1
b = 0
result = a / b
print(result)

输出
    result = a / b
ZeroDivisionError: division by zero
1
2
3
4
5
6
7
8

映射中没有这个键：KeyError

dic={'name':'张三','age':22}
print(dic['gender'])  #字典中没有这个键

输出
    print(dic['gender'])
KeyError: 'gender'
1
2
3
4
5
6

未声明初始化对象(没有属性)：NameError

print(key)

输出
    print(key)
NameError: name 'key' is not defined
1
2
3
4
5

传入无效的参数：ValueError

a=int('hello')

输出
    a=int('hello')
ValueError: invalid literal for int() with base 10: 'hello'
1
2
3
4
5

11.2 不同异常类型的处理方式

1、注释掉可能出错的代码进行调试
2、对关键字print()进行调试

11.3 异常处理机制

Python提供了异常处理机制，可以在异常出现时及时捕获，然后内部消化掉，让程序继续运行

11.3.1 多个except结构

while(1):
    try:
        a = int(input('请输入第一个正数'))
        b = int(input('请输入第二个正数'))
        result = a / b
        print('结果为：', result)
    except ZeroDivisionError:
        print('除数不允许为0')
    except ValueError:
        print('只能输入数字串')
        
输出
请输入第一个正数
只能输入数字串
请输入第一个正数1
请输入第二个正数0
除数不允许为0
请输入第一个正数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

11.3.2 try…except…else结构

try:
    a = int(input('请输入第一个正数'))
    b = int(input('请输入第二个正数'))
    result = a / b
except BaseException as e:  #所有的异常都会被捕获，异常的别名叫做e
    print('出错了',e)
else:
    print('结果为：',result)

输出
请输入第一个正数w
出错了 invalid literal for int() with base 10: 'w'
1
2
3
4
5
6
7
8
9
10
11
12

11.3.3 try…except…else…finally结构

try:
    a = int(input('请输入第一个正数'))
    b = int(input('请输入第二个正数'))
    result = a / b
except BaseException as e:  #所有的异常都会被捕获，异常的别名叫做e
    print('出错了',e)
else:
    print('结果为：',result)
finally:
    print('无论是否出错，凑会执行此句，谢谢您的使用')
    
输出
请输入第一个正数1
请输入第二个正数2
结果为： 0.5
无论是否出错，凑会执行此句，谢谢您的使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

11.3.4 traceback模块

import traceback
try:
    num=10/0
except:
    traceback.print_exc()

    输出
        num=10/0
ZeroDivisionError: division by zero
1
2
3
4
5
6
7
8
9

第十二章 面向对象（一）

12.1 类和对象的创建

类的创建：

class Student:
    native_pace='吉林'   #直接写在类里的变量，称为类属性
    
    def __int__(self,name,age):
        self.name=name   #self.name称为实体属性，进行了一个赋值操作，将局部变量的name的值赋给实体属性
        self.age=age

    #实例方法
    def eat(self):       #实例方法    在类之外定义的称为函数，在类之内定义的称为方法
        print('学生在吃饭')

    #静态方法
    @staticmethod
    def method():
        print('我使用staticmethod进行修饰，所以我是静态方法')

    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')


def drink():     #函数
    print('喝水')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
'
运行
运行

对象的创建：

#创建Student的实例对象
stu1=Student('张三',22)   #注意类中init方法是不是有两个参数
print(stu1.name)
print(stu1.age)

输出
张三
22

1
2
3
4
5
6
7
8
9

12.2 类属性、类方法、静态方法

类属性：类中方法外的变量称为类属性，被该类的所有对象共享

stu2=Student('李四',20)
stu3=Student('王五',21)
print(stu2.native_pace)      
print(stu3.native_pace)

输出
吉林
吉林
1
2
3
4
5
6
7
8

类方法：使用@classmethod修饰的方法，使用类名直接访问的方法

stu1.eat()            #对象名.方法名
Student.eat(stu1)     #类名.方法名（类的对象）    两者的代码功能相同，都是调用Student中的eat方法

输出
学生在吃饭
学生在吃饭
1
2
3
4
5
6

静态方法：使用@staticmethod修饰的方法，使用类名直接访问的方法

12.3 动态绑定属性和方法

动态绑定属性

stu1.gender='女'   #起始创建的类没有gender属性，后期对对象动态绑定
print(stu1.gender)
print(stu2.gender)

输出
女
Traceback (most recent call last):
  File "D:/pythonproject/vippython/chap12/demo3.py", line 14, in <module>
    print(stu2.gender)
AttributeError: 'Student' object has no attribute 'gender'
1
2
3
4
5
6
7
8
9
10

动态绑定方法

def show():
    print('定义在类之外的称为类函数')

stu1.show=show
stu1.show()
stu2.show()

输出
    stu2.show()
AttributeError: 'Student' object has no attribute 'show'
定义在类之外的称为类函数
1
2
3
4
5
6
7
8
9
10
11

第十三章 面向对象（二）

13.1 封装

⚪封装：提高程序的安全性，将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。
⚪在python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个’‘_’’

class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age  #年龄不希望在类的外部被使用，所以加两个下划线

    def show(self):
        print(self.name,self.__age)

stu=Student('张三',20)
stu.show()
#print(stu.__age)  出错，类对象外部访问
#print(dir(stu))
print(stu._Student__age)  #在类的外部可以通过 _Student__age 进行访问

输出
张三 20
20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

13.2 继承

⚪提高代码的复用性
⚪如果一个类没有继承任何类，则默认继承object类
⚪python支持多继承
⚪定义子类时，必须在其构造函数中调用父类的构造函数

class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print('姓名:{0}，年龄:{1}'.format(self.name,self.age))

class Student(Person):
    def __init__(self,name,age,score):
        super().__init__(name,age)
        self.score=score

class Tercher(Person):
    def __init__(self,name,age,tno):
        super().__init__(name,age)
        self.tno=tno

stu=Student('Jack',20,'100')
tea=Tercher('Tom',40,'1001')
stu.info()
tea.info()
print(stu.score)
print(tea.tno)

输出
姓名:Jack，年龄:20
姓名:Tom，年龄:40
100
1001
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

13.3 方法重写

⚪如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其（方法体）进行重新编写
⚪子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法

class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print('姓名:{0}，年龄:{1}'.format(self.name,self.age))

class Student(Person):
    def __init__(self,name,age,score):
        super().__init__(name,age)
        self.score=score

class Tercher(Person):
    def __init__(self,name,age,tno):
        super().__init__(name,age)
        self.tno=tno
    def info(self):    #重写
        super().info()
        print(self.tno)

stu=Student('Jack',20,'100')
tea=Tercher('Tom',40,'1001')
stu.info()
tea.info()

输出
姓名:Jack，年龄:20
姓名:Tom，年龄:40
1001
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

13.4 object类

⚪object类是所有类的父类，因此所有类都有object类的属性和方法。
⚪内置函数dir()可以查看指定对象所有属性
⚪object有一个__str__()方法，用于返回一个对于“对象的描述”,对应于内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对__str__()进行重写

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return '我的名字是:{0},今年:{1}岁了'.format(self.name,self.age)
stu=Student('张三',22)
print(dir(stu))
print(stu)   #默认会调用__str__()这样的方法
print(type(stu))
输出
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name']
我的名字是:张三,今年:22岁了
<class '__main__.Student'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

13.5 多态

⚪提高程序的可拓展性和可维护性
⚪简单地说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行的过程中根据变量所引用的对象的类型，动态决定调用哪个对象中的方法

class Animal(object):
    def eat(self):
        print('动物会吃')

class Cat(Animal):
    def eat(self):
        print('猫吃鱼')

class Dog(Animal):
    def eat(self):
        print('狗吃骨头')

class Person:
    def eat(self):
        print('人吃五谷杂粮')

#定义一个函数
def fun(obj):
    obj.eat()

#开始调用函数
fun(Cat())
fun(Dog())
fun(Animal())
fun(Person())

输出
猫吃鱼
狗吃骨头
动物会吃
人吃五谷杂粮
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

13.6 特殊方法和特殊属性

注：横杠为下划线，表格的问题，下划线打不出来

13.6.1 特殊属性

#print(dir(object))   查看属性和方法

class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age
class D(A):
    pass


#创建C类的对象
x=C('Tom',20)  #是C类的一个实例对象
print(x.__dict__)    #实例对象的属性字典
print(C.__dict__)    #类对象的属性和方法的字典
print('-------------------')
print(x.__class__)   #输出对象所属的类
print(C.__bases__)   #C类的父类类型的元素
print(C.__base__)    #同上，输出一个
print(C.__mro__)     #类的层次结构
print(A.__subclasses__())     #子类的列表



输出
{'name': 'Tom', 'age': 20}
{'__module__': '__main__', '__init__': <function C.__init__ at 0x0000023C0BE087B8>, '__doc__': None}
-------------------
<class '__main__.C'>
(<class '__main__.A'>, <class '__main__.B'>)
<class '__main__.A'>
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
[<class '__main__.C'>, <class '__main__.D'>]

进程已结束,退出代码0
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

13.6.2 特殊方法

add()方法

a=20
b=100
c=a+b
d=a.__add__(b)

print(c,d)

class Student:
    def __init__(self,name):
        self.name=name
    def __add__(self, other):
        return self.name+other.name

stu1=Student('Tom')
stu2=Student('Jack')

s=stu1+stu2  #实现了两个对象的加法运算（因为在Student类中 编写__add__()特殊方法）
print(s)
s=stu1.__add__(stu2)
print(s)

输出
120 120
TomJack
TomJack
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

len()方法

lst=[11,22,33,44]
print(len(lst))
print(lst.__len__())    #查看对象的长度

class Student:
    def __init__(self,name):
        self.name=name
    def __len__(self):
        return len(self.name)   #在类方法中定义，就可以查看字符的长度

stu=Student('Jack')
print(stu.__len__())


输出
4
4
4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

new()方法
init()方法

class Person(object):

    def __new__(cls, *args, **kwargs):
        print('__new__被调用执行了，cls的id值为{0}'.format(id(cls)))        # 1416
        obj=super().__new__(cls)
        print('创建的对象的id为{0}'.format(id(obj)))                       # 5904
        return obj

    def __init__(self,name,age):
        print('__init__被调用执行了，self的id值为{0}'.format(id(self)))     # 5904
        self.name=name
        self.age=age

print('objece这个类对象的id为：{0}'.format(id(object)))                     # 2800
print('Person这个类对象的id为：{0}'.format(id(Person)))                     # 1416

#创建Person类的实例对象
p1=Person('Tom',20)
print('p1这个Person类的实例对象的id为：{0}'.format(id(p1)))                   # 5904
输出
objece这个类对象的id为：1688742800
Person这个类对象的id为：2109440721416
__new__被调用执行了，cls的id值为2109440721416
创建的对象的id为2109442655904
__init__被调用执行了，self的id值为2109442655904
p1这个Person类的实例对象的id为：2109442655904

进程已结束,退出代码0
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

13.7 类的浅拷贝与深拷贝

13.7.1 变量的赋值操作

只是形成两个变量，实际上还是指向同一个对象

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk

cpu1=CPU()
cpu2=cpu1
print(cpu1,id(cpu1))
print(cpu2,id(cpu2))
输出
<__main__.CPU object at 0x0000027A9D0D4F60> 2725644160864
<__main__.CPU object at 0x0000027A9D0D4F60> 2725644160864
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

13.7.2 浅拷贝

python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk

#变量的赋值
cpu1=CPU()
cpu2=cpu1

#类的浅拷贝
disk=Disk()
computer=Computer(cpu1,disk)  #创建一个计算机类的对象
print(computer,computer.cpu,computer.disk)

#浅拷贝
import copy
computer2=copy.copy(computer)
print(computer2,computer2.cpu,computer2.disk)
输出
<__main__.Computer object at 0x0000024C64E00278> <__main__.CPU object at 0x0000024C64DF4F60> <__main__.Disk object at 0x0000024C64E00240>
<__main__.Computer object at 0x0000024C64E002E8> <__main__.CPU object at 0x0000024C64DF4F60> <__main__.Disk object at 0x0000024C64E00240>
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

13.7.3 深拷贝

使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk

#变量的赋值
cpu1=CPU()
cpu2=cpu1

#类的浅拷贝
disk=Disk()
computer=Computer(cpu1,disk)  #创建一个计算机类的对象
print(computer,computer.cpu,computer.disk)

#浅拷贝
import copy
computer2=copy.copy(computer)
print(computer2,computer2.cpu,computer2.disk)

#深拷贝
computer3=copy.deepcopy(computer2)
print(computer3,computer3.cpu,computer3.disk)
输出
<__main__.Computer object at 0x000002897DCC0240> <__main__.CPU object at 0x000002897DCB4B00> <__main__.Disk object at 0x000002897DCB4F60>
<__main__.Computer object at 0x000002897DCC02B0> <__main__.CPU object at 0x000002897DCB4B00> <__main__.Disk object at 0x000002897DCB4F60>
<__main__.Computer object at 0x000002897DCC0278> <__main__.CPU object at 0x000002897DCC0588> <__main__.Disk object at 0x000002897DCC0B70>
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

第十四章 模块

14.1 什么叫模块

⚪模块的英文为Moudules
⚪函数与模块的关系：一个模块中可以包含许多函数
⚪在python中一个拓展名为.py的文件就是一个模块
⚪使用模块的好处：
1、方便其他程序和脚本的导入并使用
2、避免函数名和变量名冲突
3、提高代码的可维护性
4、提高代码的可重用性

14.2 自定义模块

⚪创建模块：新建一个.py文件，名称尽量不要与python自带的便准模块名称相同
⚪导入模块： import 模块名称 [ as 别名 ]
from 模块名称 import 函数/变量/类

导入系统模块：

import math      #关于数学运算
print(type(math))
print(math)
print(math.pi)
print('-------------------')
print(dir(math))
print(math.pow(2,3))       #幂
print(math.ceil(9.001))    #向上取整

输出
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
8.0
10
1
2
3
4
5
6
7
8
9
10
11
12
13

import math
from math import pi   #仅仅导入math模块中的pi方法 直接使用别的方法则报错
print(pi)
print(math.pow(2,3))

输出
3.141592653589793
8.0
1
2
3
4
5
6
7
8

导入自定义的模块：

# 自定义calc模块

def add(a,b):
    return a+b

def sub(a,b):
    return a-b
1
2
3
4
5
6
7
'
运行
运行

#自定义result模块
import calc   #导入自定义的calc模块
print(calc.add(10,20))
print(calc.sub(20,10))

输出
30
10
1
2
3
4
5
6
7
8

from calc import add  #导入自定义模块中的一个函数
print(add(10,20))

输出
30
1
2
3
4
5

14.3 以主程序的形式执行

⚪每个模块的定义中都包括一个记录模块名称的变量__name__，程序可以检查该变量，以确定他们在哪个模块中执行。如果一个模块不是被导入到其它程序中执行，那么它可能在解释器的顶级模块中执行。顶级模块的__name__变量的值为__main__

例如：

#自定义calc2模块

def add(a,b):
    return a+b

print(add(1,2))
1
2
3
4
5
6
'
运行
运行

#自定义result2模块
import calc2
print(calc2.add(100,200))

输出
3       #会把导入的模块中的也一并输出
300
1
2
3
4
5
6
7

此时可在源模块中加入这样的代码（以主程序方式运行）：

#自定义calc2模块

def add(a,b):
    return a+b

if __name__ == '__main__':    #表示仅在运行此模块中才会执行以下的代码
    print(add(1,2))
1
2
3
4
5
6
7
'
运行
运行

#自定义result2模块
import calc2
print(calc2.add(100,200))

输出
300
1
2
3
4
5
6

14.4 python中的包

⚪包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下
⚪作用：代码规范、避免模块冲突
⚪包与目录的区别：
1、包含__init__.py文件的目录称为包
2、目录里通常不包含__init__.py文件
⚪包的导入：import 包名.模块名

import pac.module_a as a   #导入pac包中的module_a模块 并把此模块赋别名a
print(a.a)

'''import pac.module_a     #导入pac包中的module_a模块
print(pac.module_a.a)'''  

#两者功能一样
1
2
3
4
5
6
7

注意：
1、使用import方式进行导入时，只能跟包名或模块名
2、使用from…import…可以导入包、模块、函数、变量

import pac
import pac.module_a
import calc
from pac.module_a import a
from pac import module_a
1
2
3
4
5

14.5 python中常用的内置模块

sys

import sys
print(sys.getsizeof(24))
print(sys.getsizeof(45))
print(sys.getsizeof(True))
print(sys.getsizeof(False))
输出
28
28
28
24
1
2
3
4
5
6
7
8
9
10

time

import time
print(time.time())
print(time.localtime(time.time()))
输出
1664938688.4037917
time.struct_time(tm_year=2022, tm_mon=10, tm_mday=5, tm_hour=10, tm_min=58, tm_sec=8, tm_wday=2, tm_yday=278, tm_isdst=0)
1
2
3
4
5
6

urllib

import urllib.request
print(urllib.request.urlopen('http://www.baidu.com').read())#读取百度服务器返回的
1
2

14.6 第三方模块的安装及使用

第三方模块的安装：pip install 模块名
第三方模块的使用：import 模块名

第十五章 文件目录操作

15.1 编码格式介绍

⚪python的解释器使用的是Unicode（内存）
⚪.py文件在磁盘上使用UTF-8存储（外存）

15.2 文件的读写操作

file=open('A.txt','r',encoding='utf-8')  #文件中有中文时编码格式改为utf-8
print(file.readlines())
file.close()

输出
['中国\n', '魅力']
1
2
3
4
5
6

15.3 常用的文件打开模式

⚪文本文件：存储的是普通“字符”文本，默认为Unicode字符集，可以使用记事本程序打开
⚪二进制文件：把数据内容用“字节”进行存储，无法用记事本打开，必须使用专门的软件打开，例如：MP3，jpg，doc

w

file=open('b.txt','w')
file.write('python')
file.close()
1
2
3
'
运行
运行

rb、wb

src_file=open('course.png','rb')

target_file=open('copy.png','wb')

print(target_file.write(src_file.read()))

target_file.close()
src_file.close()
1
2
3
4
5
6
7
8

15.4 文件对象常用的方法

15.5 with语句（上下文管理器）

with语句可以自动管理上下文资源，不论什么原因跳出with块，都能确保文件正确关闭，以此来达到释放资源的目的

with open('A.txt','r',encoding='utf-8') as file:
    print(file.read())
1
2

15.6 目录操作

15.6.1 os模块操作目录相关函数

⚪os模块是python内置的与操作系统功能和文件系统相关的模块，该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样。
⚪os模块与os.path模块用于对目录或文件进行操作

#os模块是与操作系统发相关的一个模块
import os
os.system('notepad.exe')  #打开记事本
os.system('calc.exe')     #打开计算器

#直接调用可执行文件
os.startfile('C:\Program Files (x86)\Tencent\QQ\Bin\QQ.exe')
1
2
3
4
5
6
7

import os
print(os.getcwd())
print(os.listdir('../chap15'))
#os.mkdir('newdir')
#os.makedirs('A/B/C/D')
#os.rmdir('../chap15/newdir')
#os.removedirs('A/B/C/D')
os.chdir('D:\\pythonproject\\vippython\\chap15')
print(os.getcwd())
1
2
3
4
5
6
7
8
9

15.6.2 os.path模块操作目录相关函数

import os.path
print(os.path.abspath('demo8.py'))
print(os.path.exists('demo8.py'),os.path.exists('demo9.py'))
print(os.path.join('D:\\pythonproject','demo8.py'))
print(os.path.split('D:\\pythonproject\\vippython\\chap15\\demo8.py'))
print(os.path.splitext('demo8.py'))
print(os.path.basename('D:\\pythonproject\\vippython\\chap15\\demo8.py'))
print(os.path.dirname('D:\\pythonproject\\vippython\\chap15\\demo8.py'))
print(os.path.isdir('D:\\pythonproject\\vippython\\chap15\\demo8.py'))

输出
D:\pythonproject\vippython\chap15\demo8.py
True False
D:\pythonproject\demo8.py
('D:\\pythonproject\\vippython\\chap15', 'demo8.py')
('demo8', '.py')
demo8.py
D:\pythonproject\vippython\chap15
False

进程已结束,退出代码0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21