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)) #输出变量的类型 <class 'str'>

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) #结果为100
months=[] #声明months为list类型
print(type(months)) #<class 'list'>
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) # 12
def 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)) #<class 'bool'>
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<max:
        print(b)
    a,b=b,a+b
    n=n+1
    return 'done'

#如果一个函数定义中包含yield关键字,那么这个函数就不再是一个普通函数,而是一个generator

def fib(max): #fib函数是定义了斐波拉契数列的推算规则
    n,a,b=0,0,1
    while n<max:
        yield b
    a,b=b,a+b
    n=n+1
    for x in fib(7):
        print(x)

九、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) #6

2、高阶函数

(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格式化输出

 

发布了118 篇原创文章 · 获赞 525 · 访问量 48万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 技术黑板 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览