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 转义字符

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

字符	转义字符
反斜杠	\
单引号	’
双引号	‘’
换行	n
退格	b
回车	r
空格	t

print('hellonworld')
print('hellotworld')
print('hellorworld') #world将hello进行了覆盖
print('hellobworld') #退一个格，把o退没了

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

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

输出
hello
world
hello	world
world
hellworld
http:\www.baidu.com
老师说'大家好'
hellonworld
hellonworld\

第二章 数据类型

2.1 python中的标识符与保留字

2.1.1 保留字

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

#查看所有关键字
import keyword
print(keyword.kwlist)

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'>
值 玛丽亚

常用的数据类型：整型 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

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

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

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'>

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岁

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'>

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'>

2.3 python中的注释

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

第三章 运算符

3.1 输入函数input

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

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

输出
大圣想要什么礼物呢?
金箍棒
金箍棒 <class 'str'>

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

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

3.2.3 比较运算符

比较运算符的结果是bool型

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

输出
a>b吗 False

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

3.2.5 位运算符

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

输出
2
0
12
16

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

4.4.2 双分支if…else结构

s=int(input('请输入一个整数'))
if s%2==0:
    print(s,'是偶数')
else:
    print(s,'是奇数')
    
输出
请输入一个整数5
5 是奇数

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

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

输出
10小于20

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级

4.5 pass空语句

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

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

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

进程已结束,退出代码0

第五章 循环

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]

5.2 while循环

a=1
while a<5:
    print(a)
    a+=1
 
输出
1
2
3
4

5.3 for-in循环

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

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

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
密码错误
对不起，三次密码均错误

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

6.2 列表的查询操作

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

输出
0
2

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]

6.3 列表元素的增删改操作

6.3.1 增

6.3.1.1 append()函数

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

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

输出
[10, 20, 30, 100]

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]]

6.3.1.3 insert()函数

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

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

输出
[10, 20, 30]

6.3.1.4 切片

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

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

输出
[10, 'hello', 40]

6.3.2 删

6.3.2.1 remove()函数

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

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

输出
[10, 20, 40, 30]

6.3.2.2 pop()函数

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

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

输出
[10, 30, 40]

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]

6.3.2.4 clear()函数

清空列表

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

输出
[]

6.3.2.5 del

删除列表

lst=[10,20,30]
del lst

6.3.3 改

6.3.3.1 为指定索引赋值

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

输出
[10, 100, 30, 40]

6.3.3.2 为指定切片赋值

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

输出
[10, 100, 200, 40]

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]

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]

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]

第七章 字典

7.1 什么是字典

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

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

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

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}

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

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'])

输出
请输入你想查询的演员：张国荣
张国荣 出演了 霸王别姬

7.5 字典元素的增删改操作

7.5.1 key的判断

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

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

输出
True
False

7.5.2 字典元素的删除

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

scores.clear()
print(scores)

输出
{' 李四 ': 98, ' 王五 ': 45}
{}

7.5.3 字典元素的新增

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

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

输出
{}
{'陈六': 98}

7.5.4 字典元素的修改

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

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

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

输出
{}
{'陈六': 98}
{'陈六': 100}

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)]

7.7.2 字典元素的遍历

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

第八章 元组与集合

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',)

8.3 元组的遍历

t=tuple(('python','world',99))
print(t)
for item in t:
    print(item)
    
输出
('python', 'world', 99)
python
world
99

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'>

8.6 集合的增删改查操作

8.6.1 集合元素的判断操作

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

输出
False
True

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}

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()

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

第九章 字符串

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

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

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

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

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']

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

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

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

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

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

第十章 函数

10.1 函数的创建和调用

10.1.1 函数的创建

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

10.1.2 函数的调用

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

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

输出
3

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

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]

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])

10.4 函数的参数定义

10.4.1 默认值参数

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

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

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

输出
100 10
10 20

10.4.2 个数可变的位置参数

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

def fun(*args):
    print(args)

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

输出
(10,)
(10, 30)
(30, 80, 110)

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}

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

10.5 变量的作用域

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

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

fun()    
print(age)   #需先调用一下函数
输出
20
20

10.6 递归函数

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

输出
720

第十一章 BUG

11.1 异常的常见类型

语法错误：SyntaxError

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

输出
    if int(age)>=18
                  ^
SyntaxError: invalid syntax

索引越界错误：IndexError

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

输出
    print(lst[4])
IndexError: list index out of range

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

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

输出
    result = a / b
ZeroDivisionError: division by zero

映射中没有这个键：KeyError

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

输出
    print(dic['gender'])
KeyError: 'gender'

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

print(key)

输出
    print(key)
NameError: name 'key' is not defined

传入无效的参数：ValueError

a=int('hello')

输出
    a=int('hello')
ValueError: invalid literal for int() with base 10: 'hello'

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
请输入第一个正数

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'

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
无论是否出错，凑会执行此句，谢谢您的使用

11.3.4 traceback模块

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

    输出
        num=10/0
ZeroDivisionError: division by zero

第十二章 面向对象（一）

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('喝水')

对象的创建：

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

输出
张三
22

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

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

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

输出
吉林
吉林

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

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

输出
学生在吃饭
学生在吃饭

静态方法：使用@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'

动态绑定方法

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

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

输出
    stu2.show()
AttributeError: 'Student' object has no attribute 'show'
定义在类之外的称为类函数

第十三章 面向对象（二）

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

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

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

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'>

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())

输出
猫吃鱼
狗吃骨头
动物会吃
人吃五谷杂粮

13.6 特殊方法和特殊属性

	名称	描述
特殊属性	–dict–	获得类对象或实例对象所绑定的所有属性和方法的字典
特殊方法	–len–()	通过重写–len–()方法，让内置函数len()的参数可以是自定义类型
	–add–()	通过重写–add–()方法，可使用自定义对象具“+”功能
	–new–()	用于创建对象
	–init–()	对创建的对象初始化

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

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

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

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

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

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

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>

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>

第十四章 模块

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

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

输出
3.141592653589793
8.0

导入自定义的模块：

# 自定义calc模块

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

def sub(a,b):
    return a-b

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

输出
30
10

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

输出
30

14.3 以主程序的形式执行

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

例如：

#自定义calc2模块

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

print(add(1,2))

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

输出
3       #会把导入的模块中的也一并输出
300

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

#自定义calc2模块

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

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

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

输出
300

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、使用import方式进行导入时，只能跟包名或模块名
2、使用from…import…可以导入包、模块、函数、变量

import pac
import pac.module_a
import calc
from pac.module_a import a
from pac import module_a

14.5 python中常用的内置模块

模块名	描述
sys	与python解释器及其环境操作相关的标准库
time	提供与实时间关的各种函数的标准库
os	提供了访问操作系统服务功能的标准库
calendar	提供与日期相关的各种函数的标准库
urllib	用于读取来自网上（服务器）的数据标准库
json	用于使用JSON序列化和反序列化对象
re	用于在字符串中执行正则表达式匹配和替换
math	提供标准算数运算函数的标准库
decimal	用于进行精确控制运算精度、有效数位和四舍五入操作的十进制运算
logging	提供了灵活的记录事件、错误、警告和调试信息等日志信息的功能

sys

import sys
print(sys.getsizeof(24))
print(sys.getsizeof(45))
print(sys.getsizeof(True))
print(sys.getsizeof(False))
输出
28
28
28
24

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)

urllib

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

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', '魅力']

15.3 常用的文件打开模式

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

打开模式	描述
r	以只读模式打开文件，文件的指针将会放在文件的开头
w	以只写模式打开文件，如果文件不存在则创建文件，如果文件存在，则覆盖原有内容，文件的指针在文件的开头
a	以追加模式打开文件，如果文件不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾追加文件，文件指针在原文件末尾
b	以二进制方式打开文件，不能单独使用，需要与其它模式一起使用，如rb，wb
+	以读写方式打开文件，不能单独使用，需要与其他模式一起使用，a+

w

file=open('b.txt','w')
file.write('python')
file.close()

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()

15.4 文件对象常用的方法

方法名	说明
read([size])	从文件中读取size个字节或字符的内容返回。若省略[size]，则读取到文件末尾，即一次读取文件所有内容
readline()	从文本中读取一行内容
readlines()	把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回
write(str)	将字符串str内容写入文件
writelines(s_list)	将字符串列表s_list写入文本文件，不添加换行符
seek(offset,[whence])	把文件指针移动到新的位置，offset表示相对于whence的位置：offset为正往结束方向移动，为负往开始方向移动。whence不同的值代表不同含义：0：从文件头开始计算、1：从当前位置开始计算、2：从文件尾开始计算
tell()	返回文件指针的当前位置
flush()	把缓冲区的内容写入文件，但不关闭文件
close()	把缓冲区的内容写入文件，同时关闭文件，释放文件对象相关资源

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

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

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

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)TencentQQBinQQ.exe')

函数	说明
getcwd()	返回当前的工作目录
listdir(path)	返回指定路径下的文件和目录信息
mkdir(path[,mode])	创建目录
makedirs(path1/path2…[,mode])	创建多级目录
rmdir(path)	删除目录
removedirs(path1/path2…)	删除多级目录
chdir(path)	将path设置为当前的工作目录

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())

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

函数	说明
abspath(path)	用于获取文件或目录的绝对路径
exists(path)	用于判断文件或目录是否存在，如果存在返回True，否则返回False
join(path,name)	将目录与目录或文件名拼接起来
splitext()	分离文件名和拓展名
basename(path)	从一个目录中提取文件名
dirname(path)	从一个路径中提取文件路径，不包括文件名
isdir(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:pythonprojectvippythonchap15demo8.py
True False
D:pythonprojectdemo8.py
('D:\pythonproject\vippython\chap15', 'demo8.py')
('demo8', '.py')
demo8.py
D:pythonprojectvippythonchap15
False

进程已结束,退出代码0

最后

以上就是优雅小伙为你收集整理的python基础语法python基础语法笔记一、Python简介二、Python的基础语法的全部内容，希望文章能够帮你解决python基础语法python基础语法笔记一、Python简介二、Python的基础语法所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。