Python3基础学习总结
目录
一、Python3变量和输入输出函数
1、Python语言
2、变量
3、输入输出函数和条件判断
二、Python3列表和元组
1、List基础结构
2、List索引
3、list和tuple（列表和元组）
三、Python3字典结构
四、Python3函数基础
五、Python3循环结构和判断结构
1、循环结构
2、判断结构
六、Python3文件操作
七、Python3列表生成式
八、Python3生成器
九、Python3函数式编程
1、函数式编程
2、高阶函数
3、匿名函数
4、partial偏函数
十、Python的格式化输出
一、Python3变量和输入输出函数
1、Python语言
Python 是一种解释型、面向对象、动态数据类型的高级程序设计语言
Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
Python 是交互式语言： 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。
Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
Python 应用领域：Linux/Unix运维，开发命令行程序、桌面GUI应用（PyQt，Kivy等）， 移动 App(PyQt，Kivy等)，Web应用（Diango等框架），服务端的应用（基于TCP协议的服务器程序），网络爬虫（为搜索引擎、深度学习等领域提供数据源），数据分析，深度学习，科学计算。
菜鸟编程 廖雪峰 python解释器内置函数类型
2、变量
#变量(每条语句后可以不写分号，直接回车即可)
numeber_of_days=365 #定义变量值
str_test="China" #字符串变量
int_test=123 #整型变量
float_test=122.5 #浮点型变量
print(numeber_of_days) #输出变量值 365
print(type(str_test)) #输出变量的类型 3、输入输出函数和条件判断
input()/print() #name=input();print(name)
#空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值
s = input('birth: ') #input()返回的数据类型是str，str不能直接和整数比较，必须先把str转换成整数
birth = int(s) #int()函数将str转换为int
if birth >=2000:
print('00后')
elif birth>=1990:
print('90后')
else:
print('90前')二、Python3列表和元组
1、List基础结构
#python中数据类型转换
str_eight=str(8) #整型8装换位字符型'8'
str_eight_two="8"
int_eight=int(str_eight_two) #字符型转换为整型
float_eight=float(str_eight_two) #字符型转换为浮点型#python 中的运算符**表示指数
china=10
print(china**2) #结果为100months=[] #声明months为list类型
print(type(months)) #
print(months) #[] 此时list为空
months.append("January") #向list中添加元素（字符串）
months.append("February")
months.append(2) #向list中添加元素（整型）向同一个list中可以添加不同类型的元素
print(months) #输出list 结果为：['January', 'February', 2] 2、List索引
int_months=[1,2,3,4,5,6,7,8,9,10,11,12] #声明一个list
length=len(int_months) #获取list的长度即有多少个元素
month1=int_months[0] #获取list中的第一个元素，每个list索引是默认从0开始的
month2=int_months[1] #获取list中的第二个元素
index=len(int_months)-1 #获取list最后一个元素的索引
last_value=int_months[index] #获取list最后一个元素
last_value1=int_months[-1] #索引-1代表最后一个元素的索引，-2代表倒数第二个元素的索引#获取list中的某段元素（切片操作）
months=["Jan","Feb","Mar","Apr","May","Jun","Jul"]
two_four=months[2:4] #获取索引为2,3的值，不包括索引4的值(取头不取尾），注意索引是从0开始的，输出结果为["Mar","Apr"]
three_six=months[3:] #获取索引3以后的所有元素 ['Apr', 'May', 'Jun', 'Jul']
months=["Jan","Feb","Mar","Apr","May","Jun","Jul"]
b=months[:5:2] #取前5个元素，每两个取一个
print(b) #结果为['Jan', 'Mar', 'May']
b=months[::3] #对所有元素，每三个取一个；#结果为['Jan', 'Apr', 'Jul']#字符串也可以用切片操作，只是操作结果仍是字符串
#tuple也可以用切片操作，只是操作的结果仍是tuple
3、list和tuple（列表和元组）
list和tuple是Python内置的有序集合，一个可变，一个不可变
#list 列表
classmates=["Bob","Jim","Mar","Asia","Kry"]
classmates.append("Bill") #往list中追加元素到末尾
classmates.insert(1,"Aut") #把元素插入到指定的位置，比如索引号为1的位置
classmates.pop() #要删除list末尾的元素，用pop()方法
classmates.pop(1) #要删除指定位置的元素，用pop(i)方法，其中i是索引位置
classmates[1]="Git" #要把某个元素替换成别的元素，可以直接赋值给对应的索引位置#tuple 元组
names=("Bob","Jim",["Mar","Asia"],"Kry") #声明一个元组
#names这个tuple不能变，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的
#可以正常地使用names[0]，names[-1]，但不能赋值成另外的元素
#当定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来,可以为空names=()
names[2][0]="X"
names[2][1]="Y"
print(names) # 结果为('Bob', 'Jim', ['X', 'Y'], 'Kry')
#表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。
# tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！三、Python3字典结构
Python3字典结构 Python3字典合并的几种方法 Python对字典分别按键（key）和值（value）进行排序
四、Python3函数基础
函数基础
def printhello(): # def 定义函数
print('hello python') #函数执行部分
def printNum():
for i in range(0,10):
print(i)
return
def add(a,b):
return a+b
printhello() #调用函数
print(printNum())
print(add(1,2))#定义函数并函数调用 #把my_abs()的函数定义保存为funct.py文件中
from funct import my_abs #用from afunct import my_abs来导入my_abs()函数,注意funct是文件名（不含.py扩展名）
b=my_abs(-12)
print(b) # 12def m(): #定义空函数
pass #实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来
import math #import math语句表示导入math包，并允许后续代码引用math包里的sin、cos等函数#返回多个值得函数
def move(x,y,step,angle=0): #定义一个函数
nx=x+step*math.cos(angle)
ny=y-step*math.sin(angle)
return nx,ny
x,y=move(100,100,60,math.pi/6)
print(x,y) #结果 151.96152422706632 70.0
r=move(100,100,60,math.pi/6) #Python的函数返回多值其实就是返回一个tuple
print(r) #结果 (151.96152422706632, 70.0)#递归函数
#如果一个函数在内部调用自身本身，这个函数就是递归函数
def fact(n): #定义一个求阶乘的函数
if n==1:
return 1
else:
return fact(n-1)*n
b=fact(5)
print(b) #结果是120
#使用递归函数需要注意防止栈溢出。
# 在计算机中，函数调用是通过栈（stack）这种数据结构实现的
# 每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。
# 由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出五、Python3循环结构和判断结构
1、循环结构
#循环结构
cities=["Austin","Dallas","Houston"]
for city in cities: #for循环
print(city) #通过缩进控制整体结构
i=0
while i<3: #while循环
i+=1
print(i)
for j in range(10): #range(n)表示从0到n-1的n个数
print(j)cities=[["Austin","Dallas","Houston"],["Haerbin","Shanghai","Beijing"]] #list中的元素仍是list
for city in cities:
print(city) #输出list中的两个list元素
for i in cities: #两层for循环输出两个list中的每个元素
for j in i:
print(j)#注意：如果代码写得有问题，会让程序陷入“死循环”，也就是永远循环下去。这时可以用Ctrl+C退出程序，或者强制结束Python进程。
#注意：Python提供一个range()函数，可以生成一个整数序列，再通过list()函数可以转换为list
#例如：list(range(5)) 结果为：[0, 1, 2, 3, 4]
2、判断结构
#选择结构
cat=True #bool类型值
dog=False
print(type(cat)) #
print(8==8) #True 判断语句
print(8!=8) #False
print(10>=5) #True sample_rate=700
if(sample_rate>50): #if语句选择
print(sample_rate)
else:
print('less lan')六、Python3文件操作
f=open("e:\\testcode\\test.txt","r") #读取.txt文件
g=f.read()
print(g)
f.close() #操作完成后关闭文件f=open("e:\\testcode\\test_write.txt","w") #写入文件
f.write('123456')
f.write('\n')
f.write('24565')
f.close()weather_data=[] #声明一个天气列表list
f=open("e:\\testcode\\weather.csv","r") #读取.csv文件
data=f.read()
rows=data.split('\n') #调用split函数对行（\n ）进行切分
for row in rows:
split_row=row.split(',') #对每行的数据进行逗号','切分
weather_data.append(split_row) #将切分好的数据放入列表中
print(weather_data) #输出结果[['1', 'sundy'], ['2', 'rain'], ['3', 'sunny'], ['4', 'rain'], ['5', 'rain'], ['6', 'sunny'], ['7', 'sunny'], ['8', 'sunny'], ['']]
we=[] #遍历weather_data列表，去掉最后的['']
for i in weather_data:
if(i!=['']):
we.append(i)
weather=[]
for row in we:
weather.append(row[1]) #将每行的第二列放入list中 ，row[0]表示第一列
print(weather)
f.close()七、Python3列表生成式
m=[x*x for x in range(1,11)] #m=[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
m=[x*x for x in range(1,11) if x%2==0] #[4, 16, 36, 64, 100] 筛选出仅偶数的平方
m=[x+y for x in 'ABC'for y in 'abc'] #使用两层循环，可以生成全排列
print(m) #结果为['Aa', 'Ab', 'Ac', 'Ba', 'Bb', 'Bc', 'Ca', 'Cb', 'Cc']#列出当前目录下的所有文件和目录名，可以通过一行代码实现
import os #导入os模块
f=[d for d in os.listdir('.')] ## os.listdir可以列出文件和目录
print(f) #结果为f=['.idea', 'test01.py', 'venv', '__pycache__']#列表生成式也可以使用两个变量来生成list
d = {'x': 'A', 'y': 'B', 'z': 'C' }
m=[x+'='+y for x,y in d.items()] #m=['x=A', 'y=B', 'z=C']#把一个list中所有的字符串变成小写
L = ['Hello', 'World', 'IBM', 'Apple']
m=[s.lower() for s in L] #m=['hello', 'world', 'ibm', 'apple']八、Python3生成器
1、生成器 （generator）
#生成器generator 在Python中，这种一边循环一边计算的机制，称为生成器,能节省大量的空间
L=[x*x for x in range(1,11)]
g=(x*x for x in range(1,11)) #创建L和g的区别仅在于最外层的[]和()，L是一个list，而是一generator
next(g) #如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值
for n in g: #用for循环，generator也是可迭代对象
print(n)2、举例
斐波那契数列（Fibonacci）除第一个和第二个数外，任意一个数都可由前两个数相加得到
#1, 1, 2, 3, 5, 8, 13, 21, 34, ...
def fib(max): #fib函数是定义了斐波拉契数列的推算规则
n,a,b=0,0,1
while n#如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator
def fib(max): #fib函数是定义了斐波拉契数列的推算规则
n,a,b=0,0,1
while n九、Python3函数式编程
1、函数式编程
#函数本身也可以赋值给变量，即：变量可以指向函数
f=abs #abs()和f()等价了 变量可以指向函数，函数名也是变量
g=f(-10) #10
#变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数
def add(x,y,f): #简单的高阶函数
return f(x)+f(y)
g=add(-1,5,abs) #62、高阶函数
（1）map函数
#map()函数接收两个参数，一个是函数，一个是Iterable
# map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回
L=[1,2,3,4,5,6,7,8,9]
def f(x):
return x*x
r=map(f,L) #map()传入的第一个参数是f，即函数对象本身。
m=list(r) #由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list
print(m) #[1, 4, 9, 16, 25, 36, 49, 64, 81]
r=map(str,L) #把列表L的所有数字转化为字符串（2）reduce函数
#reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，
# reduce把结果继续和序列的下一个元素做累积计算
from functools import reduce
L=[1,2,3,4,5]
def add(x,y):
return x+y
m=reduce(add,L) #15#定义一个字符串转整数的函数（str2int）\
from functools import reduce
DIGITS={'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}
def str2int(s):
def fn(x,y):
return 10*x+y
def char2num(s):
return DIGITS[s]
return reduce(fn,map(char2num,s))（3）filter()函数用于过滤序列
#filter()也接收一个函数和一个序列
#filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素
def is_odd(n): #定义一个函数，在一个list中，删掉偶数，只保留奇数
return n%2==1
m=list(filter(is_odd,[1,2,3,4,5,6,7])) #[1, 3, 5, 7]
#filter()函数返回的是一个Iterator，也就是一个惰性序列，
# 所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list（4）sorted()函数排序函数
#可以接收一个key函数来实现自定义的排序
L=[11,2,4,-12,-15,17]
m=sorted(L) #[-15, -12, 2, 4, 11, 17]
m=sorted(L,key=abs) #按绝对值大小排序,并按照对应关系返回list相应的元素[2, 4, 11, -12, -15, 17]
S=['Bob','Ann','cll','Zmm','alt']
s=sorted(S) #对字符串排序，是按照ASCII的大小比较的['Ann', 'Bob', 'Zmm', 'alt', 'cll']
s=sorted(S,key=str.lower) #实现忽略大小写的排序['alt', 'Ann', 'Bob', 'cll', 'Zmm']
s=sorted(S,key=str.lower,reverse=True) #进行反向排序['Zmm', 'cll', 'Bob', 'Ann', 'alt']
3、匿名函数
#lambda匿名函数
#匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果
L=[1,2,3,4,5,6,7,8,9]
m=list(map(lambda x:x*x,L)) #关键字lambda表示匿名函数，冒号前面的x表示函数参数
print(m) #[1, 4, 9, 16, 25, 36, 49, 64, 81]4、partial偏函数
#partial偏函数
#functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数
import functools
int2=functools.partial(int,base=2) #二进制转换为十进制整数
m=int2('10000') #16十、Python的格式化输出
a=20 b=100
print('input:%d,output:%d'%(a,b)) #占位符
print('input:{},output:{}'.format(a,b)) #format格式化输出
print(f'input:{a},output:{b}') #f/F-string格式化输出