第一章：输入输出
1、输出函数：print()
将数据输出到文件：
fp=open('D:/text.txt','a+')
print('hello word',file=fp)
fp.close()
2、输入函数：input()
a=input('请输入一个数')
print('这个数是'+a)
3、转义字符
原字符：不希望字符串中的转义字符起作用，就可以使用原字符。即：在字符串之前加上r或R
print(r'hello world')
#最后一个字符不能是一个反斜杠
#print(r'hello world\')
第二章：数据类型
1、变量
name='liuyuhui'
#标识：内存中的地址
id(name)
#类型
type(name)
2、数据类型
整数类型：int
二进制：0b；八进制：0o；十六进制：0x；
浮点类型：float
有时计算不准确：
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))
字符串类型：str
字符串可以由单引号，双引号，三引号引出。三引号引出的字符串可以不放在同一行。
3、数据类型转换
str()#将其他类型转换为字符串类型
int()#将其他类型转换为整数类型（如果要将字符串类型转换为整数类型，字符串必须为整数串）
float()#将其他类型转换为浮点数类型（字符串转换为浮点型，字符串必须为数据串）
4、注释
单行注释：#
多行注释：‘’‘ 或 “”“
第三章：运算符
整除运算符：’//‘
一正一负做整除，结果向下取整
print(9//-4)#-3
print(-9//4)#-3
取余运算符：’%‘
一正一负做取余运算，结果按照公式：
余数=被除数-除数*商
print(9%-4)#-3
print(-9%4)#3
幂运算符：’**‘
赋值运算符：’=‘
#支持系列解包赋值
a,b,c=20,30,40
print(a,b,c)#20 30 40
#eg:交换两变量的值：
a,b=b,a
比较运算符：’==‘，’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)
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
2、循环结构
while循环
while a<5:
sum+=a
a+=1
for-in循环
for 自定义的变量 in 可迭代对象：
循环体
for i in 'python':
print(i)
else语句
与while或for循环搭配使用时，如果循环正常结束则执行else语句，如果碰到break时，不执行
第六章：数据结构
1、序列
序列的切片：
序列[x,y,z]
x:开始索引(默认为0)
y:结束索引(默认到结束)
z:步长(默认为1)
s="HelloWord"
s1=s[1:5:1]##ello
序列的操作
2、列表
列表的创建
使用[]或者list();
list1=["hello","world",34]##可以是任意类型
list2=list("hello")
list3=list(range(1,10,2))
del list3##删除列表
列表的遍历
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)
列表的相关操作
列表的排序
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)
列表生成式
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 循环确定列表大小
二维列表
#二维列表的创建 四行五列
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()#换行
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)
元组的访问与遍历
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)
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
字典的取值与遍历
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)
字典相关操作
d={10:'cat',20:'dog',30:'pig',20:'zoo'}
d[100]='duck'
#直接添加到字典元素后面
5、集合
是一个无序不重复的元素序列，是可变数据类型
集合的创建
s={10,20,30,40,50}
print(s)
#s={[10,20],[30,40]} 列表没有经过hash，不能存储在集合中
s=set('helloword')
print(s)
集合类型的操作符
交集：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指向同一地方
2、字符串的常用操作
字符串的查阅操作
字符串的大小写转换
字符串内容对齐
字符串的劈分
字符串的判断
字符串的替换与合并
字符串的比较
字符串的比较是比较其ordinal value（原始值），可用内置函数ord()，对应的chr()可以得到其对应的字符
字符串的切片
s='hello,Python'
s1=s[:5]
s2=s[6:]
s3=s[::2]
print(s1,s2,s3)#hello Python hloPto
字符串格式化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
字符串的编码转换
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'))
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)
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}
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
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']
实例：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
1738
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
