Python学习笔记（基础知识总结）

第一章：输入输出

1、输出函数：print()

将数据输出到文件：

fp=open('D:/text.txt','a+')
print('hello word',file=fp)
fp.close()
1
2
3

2、输入函数：input()

a=input('请输入一个数')
print('这个数是'+a)
1
2

3、转义字符

原字符：不希望字符串中的转义字符起作用，就可以使用原字符。即：在字符串之前加上r或R

print(r'hello world')
#最后一个字符不能是一个反斜杠
#print(r'hello world\')
1
2
3

第二章：数据类型

1、变量

name='liuyuhui'
#标识：内存中的地址
id(name)
#类型
type(name)
1
2
3
4
5

2、数据类型

整数类型：int

二进制：0b；八进制：0o；十六进制：0x；

浮点类型：float

有时计算不准确：

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

字符串类型：str

字符串可以由单引号，双引号，三引号引出。三引号引出的字符串可以不放在同一行。

3、数据类型转换

str()#将其他类型转换为字符串类型

int()#将其他类型转换为整数类型（如果要将字符串类型转换为整数类型，字符串必须为整数串）

float()#将其他类型转换为浮点数类型（字符串转换为浮点型，字符串必须为数据串）

4、注释

单行注释：#

多行注释：‘’‘ 或 “”“

第三章：运算符

整除运算符：’//‘

一正一负做整除，结果向下取整

print(9//-4)#-3
print(-9//4)#-3
1
2

取余运算符：’%‘

一正一负做取余运算，结果按照公式：

余数=被除数-除数*商

print(9%-4)#-3
print(-9%4)#3
1
2

幂运算符：’**‘

赋值运算符：’=‘

#支持系列解包赋值
a,b,c=20,30,40
print(a,b,c)#20 30 40
#eg:交换两变量的值：
a,b=b,a
1
2
3
4
5

比较运算符：’==‘，’is‘

’==‘比较值是否相等

’is’比较id是否相同

布尔运算符：‘and’，‘or’，‘not’，‘in’，‘not in’

and：全ture则ture

or：全false才false

not：取反

in/not in：(a in/not in b)a是否包含于b中

运算符优先级

1、算数 ** * / % // + -

2、位运算 << >> & |

3、比较 > < <= >= == !=（True False）

4、布尔 and or

5、等于 =

第四章：分支判断

1、对象的布尔值

bool() 获取对象的布尔值

2、多分支结构

if 条件表达式：

​ 条件执行体1

elif 条件表达式：

​ 条件执行体2

elif 条件表达式：

​ 条件执行体N

else（条件表达式）：

​ 条件执行体N+1

3、条件表达式

x if 判断条件 else y

判断条件为True执行x语句否则执行y语句

a=1
b=2
print(a if a>b else b)
1
2
3

4、pass语句

语句什么都不做，只是一个占位符，用在语法上需要语句的地方

第五章：循环

1、内置函数range()

r=range(10)
print(list(r))
r=range(1,7)
print(list(r))
r=range(1,10,3)
print(list(r))
print(4 in r)
print(4 not in r)
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#[1, 2, 3, 4, 5, 6]
#[1, 4, 7]
#True
#False
1
2
3
4
5
6
7
8
9
10
11
12
13

2、循环结构

while循环

while a<5:
    sum+=a
    a+=1
1
2
3

for-in循环

for 自定义的变量 in 可迭代对象：

​ 循环体

for i in 'python':
    print(i)
1
2

else语句

与while或for循环搭配使用时，如果循环正常结束则执行else语句，如果碰到break时，不执行

第六章：数据结构

1、序列

序列的切片：

序列[x,y,z]
x:开始索引(默认为0)
y:结束索引(默认到结束)
z:步长(默认为1)

s="HelloWord"
s1=s[1:5:1]##ello
1
2

序列的操作

2、列表

列表的创建

使用[]或者list();

list1=["hello","world",34]##可以是任意类型
list2=list("hello")
list3=list(range(1,10,2))
del list3##删除列表
1
2
3
4

列表的遍历

list1=["hello","world",34]
for item in list1:
	print(item)
for i in range(0,len(list1)):
	print(list[i])
for index,item in enumerate(list1):
    print(index,item)
for index,item in enumerate(list1,start=1):##start可以省略
    print(index,item)
1
2
3
4
5
6
7
8
9

列表的相关操作

列表的排序

lst=['a','H','j','B','e','F']
lst.sort()
print(lst)
lst.sort(reverse=True)
print(lst)
lst.sort(key=str.lower,reverse=True)
print(lst)
lst2=sorted(lst,key=str.lower,reverse=True)
print(lst2)
1
2
3
4
5
6
7
8
9

列表生成式

list=[expression for item in range (if condition)]

import random
lst=[random.randint(1,100) for item in range(10)]
print(lst)
#expression是表达式，确定列表存放内容
#for in 循环确定列表大小
1
2
3
4
5

二维列表

#二维列表的创建   四行五列
lst=[[x for x in range(5)]for y in range(4)]
#二位列表的遍历
for x in lst:
    for y in x:
        print(y,end='\t')
    print()#换行
1
2
3
4
5
6
7

3、元组

元组是内置不可变序列

元组的创建

使用()或tuple();

t=('hello',[10,20,30],'你好',10)
print(t)
t=tuple('hello word')
print(t)
del t
#如果元组中只有一个元素，不能省略'，'
t=(10,)
#如果使用生成式，结果为生成器对象，需要tuple转换成元组
t=(i for i in range(1,4))
#print(t.__next__())
#print(t.__next__())
#print(t.__next__())
#如果使用__next__()则不能再遍历t
t=tuple(t)
print(t)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

元组的访问与遍历

t=('hello',[10,20,30],'你好',10)
print(t[1])
t1=t[0:4:2]
print(t1)
for item in t:
    print(item)
for index,item in enumerate(t,start=4):
    print(index,item)
1
2
3
4
5
6
7
8

4、字典

字典的键是无序的，要求为不可变数据类型，列表不可以作为字典中的键

字典的创建

使用{}或dict()或zip()

d={10:'cat',20:'dog',30:'pig',20:'zoo'}
print(d)#当key值相同时，value会进行覆盖

list1=[2,45,8,3,5]
list2=['a','ds','d','fd','sd']
d=zip(list1,list2)
d=dict(d)
print(d)

d=dict(cat=10,dog=20)#cat为键，10为值
t=(10,20,30)
print({t:10})#t为key,10为value
1
2
3
4
5
6
7
8
9
10
11
12

字典的取值与遍历

d={10:'cat',20:'dog',30:'pig',20:'zoo'}
print(d[10])
print(d.get(20))
print(d.get(50,'不存在'))

for item in d.items():
    print(item)#结果为元组
for key,item in d.items():
    print(key,item)
1
2
3
4
5
6
7
8
9

字典相关操作

d={10:'cat',20:'dog',30:'pig',20:'zoo'}
d[100]='duck'
#直接添加到字典元素后面
1
2
3

5、集合

是一个无序不重复的元素序列，是可变数据类型

集合的创建

s={10,20,30,40,50}
print(s)
#s={[10,20],[30,40]}    列表没有经过hash，不能存储在集合中
s=set('helloword')
print(s)
1
2
3
4
5

集合类型的操作符

交集：A&B 并集：A|B 差集：A-B 补集：A^B

6、总结

第七章：字符串

字符串是基本数据类型，是一个不可变的字符序列

1、字符串的驻留机制

相同的字符串，只保留一份在驻留池中，后续创建相同的字符串时，不开辟新空间，而是把该字符的地址赋给新创的变量

驻留机制的几种情况

字符串长度为0或1时

符合标识符的字符串：只包含字母，数字，下划线

字符串只在编译时进行驻留，而非运行时

[-5,256]之间的整数数字

a='Python'
b="Python"
c='''Python'''
print(a,id(a))
print(b,id(b))
print(c,id(c))#id(a)=id(b)=id(c)
#a=sys.intern(b)可以强制让a,b指向同一地方
1
2
3
4
5
6
7

2、字符串的常用操作

字符串的查阅操作

字符串的大小写转换

字符串内容对齐

字符串的劈分

字符串的判断

字符串的替换与合并

字符串的比较

字符串的比较是比较其ordinal value（原始值），可用内置函数ord()，对应的chr()可以得到其对应的字符

字符串的切片

s='hello,Python'
s1=s[:5]
s2=s[6:]
s3=s[::2]
print(s1,s2,s3)#hello Python hloPto
1
2
3
4
5

字符串格式化format

name='张三'
age=20
print('我叫%s,今年%d岁'%(name,age))
print('我叫{0},今年{1}岁'.format(name,age))#format中第一个字符串会替换所有{0}处位置
print(f'我叫{name},今年{age}岁')
#输出都是:我叫张三,今年20岁
print('%10.3f'%3.14159)#一共占十位，小数点后占三位，右对齐
print('{0:.3}'.format(3.14159))#三位数
print('{0:.3f}'.format(3.14159))#小数点后占三位
print('{0:10.3f}'.format(3.14159))#一共占10位，小数点后占三位
#     3.142
#3.14
#3.142
#     3.142
1
2
3
4
5
6
7
8
9
10
11
12
13
14

字符串的编码转换

s='我爱Python'
print(s.encode(encoding='GBK'))
print(s.encode(encoding='UTF-8'))
#b'\xce\xd2\xb0\xaePython'
#b'\xe6\x88\x91\xe7\x88\xb1Python'
byte=s.encode(encoding='GBK')
print(byte.decode(encoding='GBK'))
1
2
3
4
5
6
7

3、正则表达式

元字符

"^“和”$"分别表示匹配的开始或结束

限定符

其他字符

re模块

第八章：函数

1、函数的创建和调用

def 函数名 ( 输入参数 )：

​ 函数体

​ [ return xxx ]

def calc(a,b):#形参
    c=a+b
    return c
result=calc(1,2)#实参
sum=calc(b=2,a=1)#关键字传参，根据形参名称进行实参传递
print(result)
1
2
3
4
5
6

2、参数传递的内存分析

如果是不可变对象，函数体内的修改不会影响实参的值

如果是可变对象，函数体内的修改会影响实参的值

3、函数的返回值

函数的返回值如果有多个，返回的结果为元组

4、函数的参数定义

个数可变的位置参数 / 个数可变的关键字形参

def calc(a,b=10):
    c=a+b
    return c
result=calc(1)#值传给a
sum=calc(2,3)


#个数可变的位置参数
#结果为一个元组
def fun(*args):
	print(args)
fun(10)
fun(10,20)
fun(10,20,30)
#(10,)
#(10, 20)
#(10, 20, 30)


#个数可变的关键字形参
#结果为一个字典
def fun(**args):
	print(args)
fun(a=10)
fun(a=10,b=20)
fun(a=10,b=20,c=30)
#{'a': 10}
#{'a': 10, 'b': 20}
#{'a': 10, 'b': 20, 'c': 30}
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

5、函数的参数总结

def fun(a,b,c):
    print(a,b,c)
lst=[11,22,33]
fun(*lst)
dic={'a':111,'b':222,'c':333}
fun(**dic)
#11 22 33
#111 222 333


#c,d只能采用关键字实参传递
def fun(a,b,*,c,d):
    print(a,b,c,d)
    

#在函数定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求，个数可变的位置形
#参放在个数可变的关键字形参之前
def fun(*a,**b):
    pass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

6、变量作用域

函数内部定义的变量叫做局部变量：作用范围只能在函数内部

函数外部定义的变量叫做全局变量：作用分为为函数内外部都可以使用

用关键字 global 声明：变量就变成全局变量

7、常用内置函数

类型转换函数

数学函数

迭代器操作函数

其他函数

实例：filter() / map()

def fun(num):
    return num%2==1
obj=filter(fun,range(10))
print(list(obj))
#[1, 3, 5, 7, 9]


def upper(x):
    return x.upper()
new_lst2=['hello','world','python']
obj2=map(upper,new_lst2)
print(list(obj2))
#['HELLO', 'WORLD', 'PYTHON']
1
2
3
4
5
6
7
8
9
10
11
12
13

实例：format()

print(format(3.14,'20'))#数值类型默认右对齐
#                3.14
print(format('hello python','20'))#字符串默认左对齐
#hello python
print(format('hello python','*<20'))#*作为填充，<左对齐，20表示宽度
#hello python********
print(format('hello python','*>20'))#>右对齐
#********hello python
print(format('hello python','*^20'))#^居中对齐
#****hello python****
print(format(3.1415926,'.2f'))#保留两位小数
#3.14**加粗样式**
print(format(20,'b'))#二进制输出    10100
print(format(20,'o'))#八进制输出    24
print(format(20,'d'))#十进制输出    20
print(format(20,'x'))#十六进制输出  14
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16