Python语言是比C和C++语言更高级的语言,Python不像C/C++那样,Python有系统自带的大整数模式,而且Python没有那么多的头文件,其中的一些模块使用起来比C/C++方便,本篇将会概述Python的一些入门,包括一些基本的块、数据类型、函数的使用等。
目录
一.输入和输出
1.字符串的读入
a=input()
print(a)
2.字符串定义时读入
a='Hello World'
print(a)
3.整型的读入
a=int(input())
print(a)
4.浮点数的读入
float型:
a=float(input())
print(a)
double型
a=float(input())
print(a)
二.模块的应用
1.math模块
import math
print(math.ceil(4.1)) #返回数字的上入整数 5
print(math.floor(4.9)) #返回数字的下舍整数 4
print(math.fabs(-10)) #返回数字的绝对值 10
print(math.sqrt(9)) #返回数字的平方根 3.0
print(math.exp(1)) #返回e的x次幂 2.718281828459045
2.random模块
随机生成一个[0,1)范围的实数
import random
ran=random.random()
print(ran)
当使用random.seed(x)设置好种子之后,random()生成的随机数将会是同一个
print("----设置随机种子----")
random.seed(10)
print("Random number with seed 10:",random.random())
3.string模块
输出:分成单引号、双引号、三引号。
print('Hello World')
print("Hello World")
print('''Hello World''')
字符串的连接
使用加运算符
str1="Hello "
str2="World"
print(str1+str2) #Hello World
使用join 运算符
a='-'.join('Hello')
print(a) #H-e-l-l-o
三.数据类型
1.列表
(1).声明一个列表,并使用下标访问元素。
names=['jack','tom','tonney','superman','jay']
print(names[0]) #jack
print(names[1]) #tom
#访问最后一个元素
print(names[-1])
print(names[len(names)-1])
(2).访问第一个元素
print(names[-5])
print(names[0])
(3).列表的查询
第一种方法:
flag=0
for name in names:
if name=="supperman":
print("有超人")
flag=1
break;
if flag==0:
print("无超人")
第二种方法:
if "supperman" in names:
print("有超人")
else:
print("无超人")
(4).列表的添加
append():在列表尾追加元素。
girls=[]
girls.append('Hello')
print(girls) #Hello
extend():合并列表。
a=['Hello','World']
girls.extend(a)
print(girls) # ['Hello','Hello',World']
insert():在指定位置添加。
girls.insert(1,'happy')
print(girls) #['Hello','happy','Hello','World']
(5).列表的修改
fruits=['apple','pear','香蕉','pineapple','草莓']
fruits[-1]='strawberry'
print(fruits) #['apple','pear','香蕉','pineapple','strawberry']
(6).列表的切片
#[]中设置要使用的第一个元素和最后一个元素的索引,牢记左闭右开
animals=['cat','dog','tiger','snake','mouse','bird']
# 正向索引 反向索引
# cat 0 -6
# dog 1 -5
#tiger 2 -4
#snake 3 -3
#mouse 4 -2
#bird 5 -1
print(animals[2:5]) #tiger snake mouse
print(animals[-1:]) #bird
print(animals[-3:-1] #snake mouse
print(animals[::2]) #从0开始,步数为2 ,cat,tiger,mouse
print(animals[-5:-1:2]) #从[-5,-1)的下标索引中,步数为2,dog snake
(7).列表的排序
生成10个不同的随机数,存放在列表中,并进行排序
import random
a=[]
i=0
while i<10:
ran=random.random(1,20)
if ran not in a: #使列表中的随机数不重复
a.append(ran)
i+=1
print(a)
#默认升序
b=sorted(a)
print(b)
#降序
b=sorted(a,reverse=True)
print(b)
2.元组(Tuple)
与列表类似,区别是元组中的内容不可以修改。
注意·:元组中只有一个元素时,需要在后面加逗号。
import random
random_list=[]
for i in range(10):
ran=random.randint(1,20) #[16,19,7,15,16,9,6,2.17]
random_list.append(ran) #(16,19,7,15,16,9,6,2,17)
print(random_list)
random_tuple=tuple(random_list)
print(random_tuple)
(1)元组的截取
print(random_tuple[0]) #16
print(random_tuple[-1]) #17
print(random_tuple[1:-3]) #(19,1,7,15,16,9,)
print(random_tuple[::-1]) #(17,2,6,9,16,15,7,1,19,16)
(2).元组的一些函数
print(max(random_tuple)) #19
print(min(random_tuple)) #1
print(sum(random_tuple)) #108
print(len(random_tuple)) #10
(3).元组的拆包和装包
#元组个数与变量的个数相等
t3=(1,2,3)
#将元素赋给a,b,c
a,b,c=t3
print(a,b,c) #1 2 3
#元组个数与变量的个数不相等
t4=(1,2,3,4,5)
#将t4[0],t4[1]分别赋给a,b;其余元素封装好赋给c
a,b,*c=t4
print(a,b,c) #1 2 [3 4 5]
print(c) [3,4,5]
3.字典(Dict)
(1).定义一个空字典
dict2={}
(2).初始化
dict2={'name':'Hello','weight':45,'age':25}
print(dict2['name']) # Hello
(3).定义一个字典,之后添加元素
dict4={}
dict4['name']='Hello'
dict4['weight']=43
print(dict4)
(4).修改字典元素
dict4['weight']=44
(5).字典相关函数
items()
dict5={'A':165,'B':166}
print(dict5.items())
for key,value in dict5.items():
if value>165:
print(key) #'B'
keys()
names=dict5.keys()
print(names) #'A','B'
values()
height=dict5.values()
print(height)
total=sum(height)
avg=total/len(height)
print(avg) #165.0
(6).字典的删除
del:
dict6={'A':1,'B':'2','C':3,'D':4}
del dict6['A']
print(dict6) #B:2 C:3 D:4
pop:
result=dict6.pop('B')
print(dict6) #C:3 D:4
四、六种最基础的数据类型
1.type
type(变量):可以返回变量的数据类型
a=10
print(type(a))#打印a的数据类型
2.数字类型
2.1.int类型(py中不用定义类型,可以直接用)
a=10
2.2.py浮点型只有float
a=1.00
print(a)
print(type(a))
2.3.complex复数类型
类似于高中学过的复数
注意:j前面的虚部数字一定要写,不然会报错
x=1+1j
print(x)
print(type(x))
3.运算符
(1)除法
/:返回一个浮点数
//:返回一个整数,相当于整除
a=2
b=1
print(a/b) #返回的是一个浮点数
print(a//b) #返回的是一个整数
(2)取余:%
a=1
b=2
print(a%b)
(3)乘法
a=2
b=3
print(a*b)
(4)乘方
a=2
b=3
print(a ** b) #2^3
4.蛇形取名法
name_and_sex
5.大驼峰小驼峰取名法
#NameAndSex
首字母大写
五、字符串string
1.python没有char类型
单引号和双引号甚至三引号都可以表示字符串
a='123456'
b="123456"
c="""123456"""
#a和b和c相等
print(a,b,c)
2.字符串的一些操作
s="i love py"
print(s.title())#给每个单词首字母大写
print(s.upper())#把所有字母变成大写
print(s.lower())#把所有字母变成小写
a = ",too"
print(s+a)#拼接
sn=f"i {a} love py"#插入字符串
#'\n'表示换行
print(1,end='123')
s=r'\n'#取消所有的转义字符
#给字符串删除一些空白
s=' 1234 '
print(s.strip())#去除头尾空格
print(s.lstrip())#去除左边的空格
print(s.rstrip())#去除右边的空格
3.字符串的切片
s="aabbccdd"
#切片
#print(s[头下标:尾下标+1:步长])
print(s[0:8:1]) #aabbccdd
print(s[0:8:2]) #abcd
print(s[7::-1]) #ddccbbaa 从左往右切片
print(s[7::-2]) #dcba
字符串不能进行更改。
4.变量的赋值,多变量赋值
x=1
y=2
z=3
x,y,z=1,2,3
六、基本序列
1.列表list补充
相当于c\c++里面的数组
List = [] #空列表
print(List)
List = [1,2,3]
print(List)
print(type(List))
#列表的切片
print(List[0:2:]) #[1,2]
print(List[1])
#修改
List[1]=3
#list里面可以套list
2.集合
#集合的性质:
#互异性
#无序性
L1={1,2}
L2={2,1}
if L1==L2:
print("ok")
else:
print("no")
#集合set和list的转换
b=[1,1,2,3,4]
b=set(b) #用于去重
a={1,2,3,4}
a.clear()
a.pop()
a.add()
a.update()
a.remove()
3.字典
#字典 相当于哈希表
#定义一个空字典
d={} #空字典
#元素类型键值对 key:value
d={'name':'zsy','sex':'male','qq':1110012}
print(d['name']) #zsy
print(d.get('name')) #通过键取值
d.pop('qq') #通过键删除
print(d.keys()) #获取所有的键
print(d.values()) #获取所有的值
d['nmae']='li' #修改
七、强制转换与输入输出处理
1.字符串和整型数字
a=1
print(str(a))
a='110'
print(a) # '110'
print(int(a)) # 110
2.list和set
L=[1,1,2,3]
L=set(L)
print(L) #123
3.基本输入输出处理
对输出的字符串进行追加处理:
names=['zsy','wq']
print(f'hello {names[0]}')
print("hello {0},{1}".format(names[0],names[1]))
基本的输入输出处理,和C++类似:
#和C语言类似的格式化输出
print("%d %f"%(5,1.0))
print("%8d %f"%(5,1.0))
print("%-8d %f"%(5,1.0))
print("%s"%('zsy'))
print("%.2f"%(5.223))
4.判断语句的用法
4.1 单分支if语句
#3.判断语句 True,False
#被视为假的:False,0,None,"",[],(),{}
#单分支if语句,必须要缩进
#if 条件表达式:
# 执行语句
a=10
if a>0:
print(True)
4.2双分支if-else语句
a=10
if a==0:
print(False)
else:
print(True)
4.3多分支if-elif语句
b=1
if b==3:
print('y')
elif b==1:
print('n')
5.比较运算符
#>,<,>=,<=,==,!=
#is,is not,in,not in
#is:双目运算符,必须两个变量值和对象都一样,才为真
#is not:和is相反
#in:判断一个是否在另一个中
a=1 #int
b=1.0 #float
#is不仅仅要求值一样,类型也要一样
if a is b: #如果换成==,输出的是y,因为==比较的仅仅是值,而is不仅比较值,而且还有类型,只有全部相同,才是一样
print('y')
else:
print('n')
#&:逻辑和 相当于and
#|:逻辑或,相当于or
#not:逻辑非
6.循环语句
6.1 for语句和while语句
#循环语句
#c/c++
#for(int i=1;i<=n;i++)
n=3
for i in range(1,n):
print('*')
#while
#continue,break
b=True
flag=0
while b:
flag+=1
print('*')
if flag==10:
continue
elif flag==15:
break
#for i in range(1,9,步长):
num=[1,2,3,4]
a=len(num) #获取序列长度
for i in num:
print(i)
6.2并行遍历
#并行遍历
#调用zip()方法
age=[18,19,17,20]
for i,j in zip(num,age):
print(i,j)
#字典的迭代
d={
'name':'zsy',
'age':20,
'sex':'male',
}
#要所有的值
for it in d:
print(it,d[it])
for it in d.values():
print(it)
# 打印键和值
for key,value in d.items():
print(key,value)
#获取1~9的平方
a=range(1,10)
b=[]
for i in range(1,9):
b.append(i*i)
#列表推倒式实现获取1~9的平方
b=[i*i for i in a]
#C:switch case
#py:match...case a | case
#异常捕捉
a=[]
try:
print(a[2])
except:
print("Program is error!")
八、序列精讲
python中序列的概述
列表,元组,字典,集合:容器,数据结构
序列的通用操作
1.索引 list[i]
2.切片
索引的进阶用法,通过两个下标或者步长来确定序列中的一段/间隔的一段。
[start:end:step]=赋值为新的序列
3.拼接
通过+,将两个序列拼接起来,两个序列对象必须相同。
4.乘法
序列*int(n),可以得到类型n个相同的序列。
print("abc"*3)
5.clear()操作
list=['1','2']
list.clear()
6.浅拷贝
相当于list的切片,全复制一遍,只会复制值,改变a不影响list.
a=list.copy() #构造了一个新的对象
a.clear()
7.深拷贝
相当于地址,如果清除b,那么list也会清除,改变b影响list。
b=list.deepcopy()
b.clear()
8.count(x)
输出序列中x的个数。
List=[1,2,3,4]
print(List.count(3))
9.extend
在序列后面追加。
List.extend({'6':6.0,'7':7.0}) #把键追加到List后面
#键:'6'
#键值对:6.0
10.index(l,r,x)
可以判断x中是否在[l,r]中,如果存在,返回下标。
print(List.index(0,3,3))
#insert(i,x):在i这个位置插入x
List.index(1,6)
11.pop()
将最后一个元素输出,还可以输出。
x=List.pop()
print(x)
12.remove(x)
把值为x的删除。
List.remove(x)
13.reverse
把序列变成相反的。
List.reverse
14.sort
List.sort() #默认升序
List.sort(reverse=True) #降序排序
List.sort(key=lambda x:x+1) #把所有的值+1后升序排序
List.sort(key=lambda x:x+1,reverse=True) #降序
15.sorted
生成一个全新的升序序列,可以做到改变新的序列,不影响原本序列。
y=List.sorted()
16字符串转换list
s='123'
l=list(s)
print(l)
17.set()
集合,集合中不能有相同的元素,可以自动去重。
list.set() #可以实现列表的去重
18.dict():字典
19.len()
返回序列长度,int型。
20.列表可以进行乘法
print([1.3]*3)
21.列表的迭代
for i in List:
print(i)
for i in List[0:3:2]:
print(i)
22.max():最大值
print(max(List))
23.min():最小值
print(min(List))
24.range(start,end,step)
常在循环中出现。
25.dict 字典
Dict={
'1':1,
'2':2
}
#'1':键
#1:键值对
26.字符串
print(s.index('d')) #找到字符串的下标
print(s.title())
s.rstrip() #去除尾空格
s.lstrip() #去除头空格
s.strip() #去除头尾空格
s.lower() #把所有的字母变成小写
s.upper() #把所有的字母变成大写
s.split('分隔符') #通过分裂
#list.split(" ") 通过空格隔开
s.join("123")
s.replace('ab','xx') #将ab替换为xx
九、函数
基础函数⽤法
1.基本格式
def 函数名(参数):
return #可以有返回值,也可以没有返回值
2.函数参数
def line():
print("-----")
# 在python中我们定义函数参数还是较为简单的,只需要在括号内按照顺序添上形参即可
def line(width):
print("-" * width)
def line(width: int, char: str):
print(char * width)
3.函数的说明⽂档
def line():
'''
打印⼀条⻓度为5的横线
return: None
'''
print("-----")
def line():
"""
print a line
:return: None
"""
print("-----")
print(line.__doc__)
# 打印结果:
# print a line
# :return: None
4.函数的返回值
def get_max(a, b):
'''获取a和b中的较⼤值'''
# 将return后⾯的值返回给外界
# return可以提前结束整个函数
return a if a > b else b
# python中三⽬运算符的⽤法:
# <表达式1> if <条件> else <表达式2>
def func(a, b):
'''获取变量a和b的和差'''
return a + b, a - b
add, reduce = func(21, 9)
# 同时需要两个变量来接收返回值
# 若只⽤⼀个变量接收,这多个值会被识别为元组,该变量则直接作为元组接收所有的值
5.变量作⽤域
a = 1 # a 为全局变量
def func():
b = 2 # b为局部变量
if 1 > 2:
v = 3 # v为局部变量
for i in range(0, 10):
m = 4 # m为全局变量
x = 1
def func():
'''change global x'''
global x
x = 2
6.参数拓展
# 值得注意的是,如果我们是想省略某个参数的传递,根据位置参数按照顺序传参的⽅式,如果
前⽅参数赋予默认值⽽后⽅参数不予默认值,则很容以看出会有逻辑上的⽭盾,故默认值只能从
后往前进⾏设置
def f(a, b = 0, c = 1):
return a + b + c
def solve(age, name="lys", status="dog"):
print(f"{name} is", end=' ')
print(f"{age} years old, and {name}", end=' ')
print(f"is a {status} .")
# solve(114514) # 第⼀个参数是必选参数,剩余参数可不选
# solve(114514, "LYS") # 不声明关键字会默认匹配除默认参数后的最近的关键字参数
# solve(114514, name="LYS")
# solve(14, status="debu cat", name="Hiiro") # 传⼊关键字参数与参数列表的
关键字对应
solve() # 缺省 age 参数
solve(name="Hiiro") # 缺省 age 参数
solve(age=114514, "debu cat") # debu cat 需要照应⼀个关键字
solve(114514, age=1919) # age 存在多个不同的值
def foo(*args, **kwargs):
print('args = ', args)
print('kwargs = ', kwargs)
print('---------------------------------------')
if __name__ == '__main__':
foo(1,2,3,4)
foo(a=1,b=2,c=3)
foo(1,2,3,4, a=1,b=2,c=3)
foo('a', 1, None, a=1, b='2', c=3)
def kw_dict(**kwargs):
return kwargs
print(kw_dict(a=1,b=2,c=3) == {'a':1, 'b':2, 'c':3})
十、高级函数的用法
1.Python函数是可以嵌套。
# 声明⼀个函数对象
def func():
print("hello!")
# 给⼀个变量浅拷⻉为func函数变量
a = func
a() # 将a作为函数⽅法调⽤
# 结果:hello!
def outer():
def inner():
print("This is inner.")
print('This is outer.')
b = inner
b()
a = outer
a()
# 结果:
# This is outer.
# This is inner.
# b = inner
# b()
# 结果:报错
def outer():
def inner():
print('This is inner.')
print('This is outer.')
return inner
a = outer
b = a() # 结果: This is outer.
b() # 结果: This is inner.
def func_1():
print('This is func_1.')
def func_2(func):
print('This is func_2.')
func() # 在func_2中调⽤func函数
func_2(func_1) # 调⽤func_2, 同时把func_1作为参数传⼊
# 结果:
# This is func_1.
# This is func_2.
2.lambda表达式
def GetAnonymous():
'''获取⼀个匿名的函数对象,且其功能为获得参数加上偏移量5的值'''
return lambda x: x + 5
a = GetAnonymous()
print(a(10))
# 结果:
# 15
3.闭包
def func(age, sex: string):
name = 'zsy'
# 如此可以防⽌name全局变量的污染
def func_1():
print(name, age)
def func_2():
print(name. sex)
func_1()
func_2()
a = func
a()
# 但实际上我们很少能⽤得上该种⽅式
def task(arg):
def inner():
print(arg)
return inner
innner_func_list = []
for val in range(0, 4):
inner_func_list.append(task(val))
for val in inner_func_list:
val()
# 结果:
# 0
# 1
# 2
# 3
"""基于多线程并⾏完成爬⾍任务"""
from concurrent.futures.thread import ThreadPoolExecutor
import requests
# 构建线程池
POOL = ThreadPoolExecutor(5)
# 三个爬⾍任务
spider_tasks = [
('哪⾥都是你mv.mp4',
'http://vodkgeyttp8.vod.126.net/cloudmusic/da70/core/b88c/70c2e21a75785
7fe8a12fe0345986398.mp4?
wsSecret=b815d122a2dd93eaf122c52686da471d&wsTime=1675325208'),
('成都mv.mp4',
'http://vodkgeyttp8.vod.126.net/cloudmusic/IjAyMCAgMyEgYDEwIDhhMg==/mv/
5619601/79bd07d7bd9394871da0c324d53f48dd.mp4?
wsSecret=efd55511ee0c07c53c230301d116d6e6&wsTime=1675325208'),
('江南mv.mp4',
'http://vodkgeyttp8.vod.126.net/cloudmusic/MTI5MDc0OTc=/d23df6673394543
e4d1dd291e566c337/767999bafb2a5d407708e2770f7725e8.mp4?
wsSecret=f010419757e1f2359119519422967ce2&wsTime=1675325208')
]
def task(url):
content = requests.get(url=url).content
# return content
print('任务:', url, '已完成!')
return content
def outer(filename):
def done(arg):
data = arg.result()
with open(filename, 'wb') as f:
f.write(data)
return done
for item in spider_tasks:
a = POOL.submit(task, item[1])
print('已分配任务:', item[0])
a.add_done_callback(outer(item[0]))
# 结果:
已分配任务: 哪⾥都是你mv.mp4
已分配任务: 成都mv.mp4
已分配任务: 江南mv.mp4
任务:
http://vodkgeyttp8.vod.126.net/cloudmusic/IjAyMCAgMyEgYDEwIDhhMg==/mv/5
619601/79bd07d7bd9394871da0c324d53f48dd.mp4?
wsSecret=efd55511ee0c07c53c230301d116d6e6&wsTime=1675325208 已完成!
任务:
http://vodkgeyttp8.vod.126.net/cloudmusic/da70/core/b88c/70c2e21a757857
fe8a12fe0345986398.mp4?
wsSecret=b815d122a2dd93eaf122c52686da471d&wsTime=1675325208 已完成!
任务:
http://vodkgeyttp8.vod.126.net/cloudmusic/MTI5MDc0OTc=/d23df6673394543e
4d1dd291e566c337/767999bafb2a5d407708e2770f7725e8.mp4?
wsSecret=f010419757e1f2359119519422967ce2&wsTime=1675325208 已完成!
# 由此在⼀系列⼯作中,闭包可以在不需要更改原本函数的情况下添加上额外的功能
4.装饰器
def func():
print('This is func.')
# 简单思路
def func():
print('before')
print('This is func.')
print('after')
# 闭包思路
def outer(func):
def inner():
print("before")
func()
print('after')
return inner
task = outer(func)
task()
"""
语法糖的使⽤:
@func
def xxx():
pass
其中,python会根据该段代码⾃动执⾏如下代码:
xxx = func(xxx)
那么我们即可以根据闭包,甚⾄可以在func中使⽤额外参数去装饰函数xxx
"""
# 闭包思路
def outer(func):
def inner():
print("before")
func()
print('after')
return inner
@outer
def func():
print('This is func.')
func() # 调⽤func
def func_1():
print('this is func_1')
def func_2():
print('this is func_2')
# ........
def outer(func):
@functools.wraps(func)
def inner(*args, **kwargs):
data = func(*args, **kwargs)
return data
return inner
# 如此即可得到相应的⽂档名称等等
5.⽣成器
def func():
yield None
def func():
'''使⽤该函数进⾏⼀个计数,每次调⽤得到⼀个更⼤的⾃然数'''
for num in range(0, 100):
print("计数ing...")
yield num
a = func() # 得到⽣成器对象
print(a) # 得到⽣成器时,是不会执⾏函数内部代码的
# 使⽤next()对象进⼊⽣成器,执⾏代码,同时可以⽤变量的到yield的返回值
num = next(a)
print(num)
num = next(a)
print(num)
num = next(a)
print(num)
# 返回结果:
# <generator object func at 0x0000021D0A50EE40>
# 计数ing...
# 0
# 计数ing...
# 1
# 计数ing...
# 2
def func():
'''使⽤该函数进⾏⼀个计数,每次调⽤得到⼀个更⼤的⾃然数'''
for num in range(0, 5):
print("计数ing...")
yield num
a = func() # 得到⽣成器对象
for item in a:
print(item)
# 结果:
# 计数ing...
# 0
# 计数ing...
# 1
# 计数ing...
# 2
# 计数ing...
# 3
# 计数ing...
# 4
def func():
for i in range(5):
v = yield i
print(v)
g = func()
g.send(None)
for i in range(4):
a = g.send('计数ing')
print(a)
# 结果:
# 计数ing
# 1
# 计数ing
# 2
# 计数ing
# 3
# 计数ing
# 4
"""
值得注意的是,send函数会直接进⾏⽣成器的迭代
"""