python教程廖雪 python基础教程廖雪峰

转载

mob64ca1402a190 2023-11-03 19:18:28

文章标签 python教程廖雪 python bc 迭代器 ci 文章分类 Python 后端开发

文章目录

输入输出

特殊字符
基本单位:list|tuple|dict|set|generator
判断:if
循环:for|while|break|continue|Iterable,iter,Iterator
函数

自定函数
函数别名
基本单位
高阶函数:map|reduce|lambda|filter|sorted
偏函数

方法

编码解码
传参
切片:list|tuple|str

调试

try except

输入输出

输入input

name = input('请输入姓名')

输出print

print('任何你想打印到窗口的内容')
print('多串字符之间','可以用逗号连接','而逗号会转换为空格')

txt

f = open(r'Users/danzhao/test.txt','r')			# 不存在则报错
f.read()
f.close()

with open(r'Users/danzhao/test.txt','r') as f:	# 同上
	f.read()

特殊字符

注释#

#井号就是注释的开始

转义符\

I\'m OK #单引号转义
\\ 		#斜杠的输入方式
\n		#换行

禁止转义r

print(r'C:\Users\example.xlsx')

缩进即是语法

a = 100
if a >= 0:
	print('非负数')
else:
	print('负数')

格式化%

print('%2d' % 3)		# 传入一个整数
print('%02d' % 3)		# 传入整数并零位补齐
print('%.2f' % 3.1415) 	# 传入一个2位小数
print('%s' % 'a')		# 传入字符串(万能)

运算符

a = 1 + 1	# 加
a = 1 - 1	# 减
a = 1 * 1	# 乘
a = 1 / 1	# 除
a = 3 % 2	# 求余
a = 2 ** 2	# 次幂

赋值

a,b = c,d

# 等价于
a = b
c = d

私有化_

def _private_1(name):
	return 'hello,%s' % name

def _private_2(name):
	return 'hi,%s' % name 

def greeting(name):
	if len(name) > 3:
		return _private_1(name)
	else:
		return _private_2(name)		# 让private仅在内部使用的标记?(无法禁止外部调用)

私域化变量__score

class student:
	def __init__(self,score):
		self.__score = score

特殊变量__score__

__author__ = 'Dan'

基本单位:list|tuple|dict|set|generator

list

alist = ['1',2,'teststr']

增

alist = []				# 定义变量为列表
alist = list(range(10))	# list类型转换
alist.appned('abc')		# 在列表末尾追加元素
alist.insert(1,'xyz') 	# 在列表位置1插入元素,其他元素右移

列表推导式list comprehensions

# 基本写法
blist = [x * x for x in range(100)]

# 等价于
blist = []
for x in range(100):
	a = x * x
	blist.append(a)

# 列表推导式加条件
clist = [x * x for x in range(100) if x % 2 == 0] # [...for...if...]

# 等价于
clist = []
for x in range(100):
	if x % 2 == 0:
		a = x * x
		clist.append(a)

# 列表推导式加完整条件
clist = [x if x % 2 == 0 else -x for x in range(100)]	# [...if...else...for...]

# 等价于
clist = []
for x in range(100):
	if x % 2 == 0:
		clist.append(x)
	else:
		clist.append(-x)

# 列表推导式嵌套
dlist = [m + n for x in 'abc' for y in 'xyz']	# 笛卡尔积


# 等价于
dlist = []
for m in 'abc':
	for n in 'xyz':
		r = m + n
		dlist.append(r)

# 字典
elist = ['%s=%s' % (k,v) for k,v in d.items()]

删

alist.pop()		# 删除末位元素
alist.pop(1)	# 删除原来位置在1的元素

查

len(alist)	# 查看列表长度
alist[0]	# 查看列表左起第1个元素
alist[1]	# 查看列表左起第2个元素
alist[-1]	# 查看列表右起第1个元素
alist[-2]	# 查看列表右起第2个元素

改

alist[1] = 'what'	# 用what替换原来位置1的元素

tuple

atuple = ('123',2,'exstr')

增

atuple = ()		# 定义变量为元组(元组不可变)
atuple = (1,)	# 定义1个元素的元组(必须带逗号)

删:不能删
查:与List一样
改

atuple = ('1','2',['3','4'])
atuple[1] = 'abc'	# 用abc来替换原来位置1的元素.替换失败
atuple[2][0] = '5'	# 将'3'替换为'5'

dict
增

d = {}								# 定义变量为字典
d = {'mj':95,'bob':79,'jack':100}	# 字典是一种key-value成对出现的类型
d['rose'] = 61						# 不存在则新增,存在则更改

删

d.pop('rose')	# 根据key值删除key-value键对

查

d['mj']				# 按照key值查找
d['jason']			# 不存在的key值会报错
'jason' in d		# jason是否存在于字典d的key值中
d.get('jason')		# 如果不存在会返回None(不返回结果,表示啥都没有)
d.get('jason','no')	# 不存在返回指定字符:no

改

d['mj']=59

set
增

s = set([1,2,3])	# set继承了字典key的特性(不重复)
s = set([1,2,2,3])	# 与上等价
s.add(4)			# 增加值(无序)

删

s.remove(4)			# 删除值

查
改
运算

s1 = ([1,2,3])
s2 = ([2,3,4])
s1 & s2			# 取交集
s1 | s2			# 取并集

generator
生成器:生成元素然后一个个释放(一边循环一遍计算)
增

g = (x * x for x in range(10))	# 与列表推导式仅仅是中括号变成了小括号的区别
g = iter([1,2,3,4])				# 类似列表内嵌套元组

删
查

next(g)	# 不断重复执行该语句到报错为止

for n in g:
	print(n)	# 用循环取数

def fib(max):
	n,a,b = 0,0,1
	while n < max:
		yield b			# 在函数中 用yield返回generator
		a,b = b,a+b
		n += 1
	return 'Done'		# return即为结束generarot

改

判断:if

age = 18 
if age > 18:
	print('成年了')
elif age > 14:
	print('法定')
else:
	print('未成年')

循环:for|while|break|continue|Iterable,iter,Iterator

names = ['Jack','Rose','Little']
for name in names:
	print(name)

list,tuple,字符循环

for a in alist:
	print(a)

for a in atuple:
	print(a)

for a in astr:
	print(a)

alstp = [(1,2),(2,4),(3,9)]	# 嵌套循环
for a,b in alstp:
	print(a,b)

dict循环

d = {'a':1,'b':2}

key循环

for k in d:
	print(k)

value循环

for v in d.values():
	print(v)

key-value循环

for k,b in d.items():
	print('key:%s' % k)
	print('value:%s' % v)

for k in d:
	print('key:%s' % k)
	print('value:%s' % d[k])

下标循环
下标和内容一起循环

alist = ['jack','rose','green']
for index,value in alist:
	print(index,value)

for i in range(len(alist)):
	print(i,alist[i])

while

sum = 0
n = 99
while n > 0:
	sum += n
	n -= 2
print(sum)

break
中断循环

names = ['Jack','Rose','Little']
for name in names:
	if name = 'Rose':
		break
	else:
		print(name)

x = 0
while x < 99:
	if x > 50:
		break
	else:
		x += 1

continue
跳过此次循环,进入下一次循环

n = 0
while n < 10:
	n += 1
	if n % 2 == 0:
		continue 	# 如果满足条件则直接跳到下一个循环,不执行后面的语句
	print(n)

Iterable,iter,Iterator
Iterrable : 可循环的

from collectioins.abc import Iterable
isinstance([],Iterable)						# list是可循环的
isinstance((1,),Iterable)					# tuple是可循环的
isinstance({},Iterable)						# dict是可循环的
isinstance('abc',Iterable)					# str是可循环的
isinstance((x for x in range(10)),Iterable)	# generator是可循环的
isinstance(100,Iterable)					# num是不可循环的

Iterator : 迭代器
可以被next()函数调用的

from collections.abc import Iterator		
isinstance([],Iterator)						# list不属于迭代器
isinstance((1,),Iterator)					# tuple不属于迭代器
isinstance({},Iterator)						# dict不属于爹地阿奇
isinstance('abc',Iterator)					# str不属于迭代器
isinstance((x for x in range(10)),Iterator)	# generator属于迭代器
isinstance(123,Interator)					# num不属于迭代器

iter : 迭代器化
这是一个函数,用来将循环对象变成迭代器

isinstance(iter([]),Iterator)				# list迭代器化
isinstance(iter((1,),Iterator)				# tuple迭代器化
isinstance(iter({}),Iterator)				# dict迭代器化
isinstance(iter('abc',Iterator)				# str迭代器化
isinstance((x for x in range(10)),Iterator)	# 本来就是迭代器
isinstance(iter(123),Iterator)				# num无法迭代器化(不可循环)

函数

自定函数

def my_abs(x):
	if x >= 0:
		return x	
	else:
		return -x
# 到return就会结束
#  如果没有return会返回None,可以写为return None或return(不接其他)
#  什么也不返回可以写pass来占位

# 可以将这个函数保存在abstest.py文件,在其他地方调用.可以认为是自建模块
from abstest import my_abs

import math
def move(x,y,step,angle=0):
	nx = x + step * math.cos(angle)
	ny = y - step * math.sin(angle)
	return nx,ny
	# 可以返回多个值(返回的是tuple)

x,y = move(100,100,60,math.pi/6)	# 将两个值分别赋值给x,y
z = move(100,100,60,math.pk/6)		# 返回一个tuple

函数参数
位置参数

def power(x):
	return x * x

默认参数

必须参数在前,默认参数在后
默认参数必须指向不变对象(最好不是list)

def power(x,n=2):
	s = 1
	while n > 0:
		n = n - 1
		s = s * x
	return s

可变参数
星号*
参数会被组装成一个tuple,参数数量可以为0

def calc(*numbers):
	sum = 0
	for i in numbers:
		sum = sum + n * n
	return sum

calc(1,2,3,4)
num = [1,2,3]
calc(*num)		# 将list或tuple传入参数的时候加一个星号*

关键字参数
双星号**
可选参数,这部分的输入会被打包成字典

def person(name,age,**kw):
	print('name':name,'age':age,'other':kw)

person('jack',18)							# 传入必选参数
person('jack',18,city='beijing')			# 传入1个关键字参数
person('jack',18,city='beijing',job='bi')	# 传入2个关键字参数

extra = {'city':'beijing','jon':'bi'}
person('jack',18,**extra)	# 将字典传入关键字参数加两个星号**

命名关键字参数
星号*,但是是作为分隔符,*后面的参数必须写参数名,也必须传入

def person(name,age,*,city,job):
	print(name,age,city,job)

person('jack',18,city='beijing',job='bi')	# 正确的示范

def person(name,age,*,city='beijing',job):	# 可以使用默认参数
	print(name,age,city,job)

person('jack',18,job='bi')	# city参数有默认值

参数优先级
必选参数>默认参数>可变参数>命名关键字参数>关键字参数

def f1(a,b,c=0,*args,**kw):
	print('必选参数':a,'必选参数':b,'默认参数':c,'可变参数':args,'关键字参数':kw)

f1(1,2)					# 只有必选参数
f1(1,2,3)				# 加默认参数	
f1(1,2,3,'a','b')		# 加可选参数
f1(1,2,3,'a','b',x=99)	# 加关键字参数

args=(1,2,3,4)
kw = {'d':99,'x':'#'}
f1(*args,**kw)			# 奇妙的用法,会自动对应abc args kw   
# Σ(⊙▽⊙"a

def f2(a,b,c=0,*,d,**kw):
	print(a,b,c,d,kw)

f2(1,2,d=99,kw={'ext':None})

args=(1,2,3)
kw = ('d':88,'x':'#'}
f2(*args,**kw) # 会自动对应 Σ(⊙▽⊙"a

函数别名

b = abs(-20)
a = abs			# 将abs函数用a替代
c = a(-20)

基本单位

range

一般用来循环

for x in range(5):
	sum += x

用来生成List

alist = list(range(5))

数据类型转换

int('123')		# 转换为整数
float('12.34')	# 转换为小数
str(1.23)		# 转换为文本
bool			# 转换为布尔

类型判断

isinstance(x,(int,float))			# x是否是int,float其中之一
from collections import Iterable
isinstance(x,Iterable)				# x是否可以循环

type(x)								# 直接查看x是什么类型(class)
if type(x) == int or type(x) == float:	# 等价于isinstance(x,(int,float))
	print('y')

编码解码

ord('A')	# 字符转数字
chr(65) 	# 数字转字符

len('abc')	# 查看字符串长度

高阶函数:map|reduce|lambda|filter|sorted

函数嵌套

map
逐个遍历

def f(x):
	return x * x

r = map(f,[1,2,3,4,5,6])	# 将列表中的每个数都使用函数f,即二次方
>>> [1,4,9,16,25,36]

reduce
累计遍历

from functolls import reduce
def f(x):
	return x * x

r = reduce(f,[1,2,3,4,5,6])	# 1 * 2 * 3 * 4 * 5 * 6
>>>

lambda
匿名函数,或者理解为不需要写函数名不需要写return的函数,快速函数等等

r = map(lambda x:x*x ,[1,2,3,4,5,6]	# 同上map

from functools import reduce 
r = reduce(lambda x:x*x,[1,2,3,4,5,6])	# 同上reduce

filter
过滤掉对象中不符合的,剩下符合的

def f(x):
	return x % 2 == 1

list(filter(f,[1,2,3,4])
>>> [1,3]

sorted
排序函数

sorted([1,-2,3,-4])	# 默认升序
>>> [-4,-2,1,3]

sorted([1,-2,3,-4],reverse=True)	# 反序,降序
>>> [3,1,-2,-4]

sorted([1,-2,3,-4],keys=abs)	# 传入函数指定顺序
>>> [1,-2,3,-4]

偏函数

快速修改函数的默认参数

def int2(x,base=2):		#原int的base参数默认为10,即int(x,base=10)
	return int(x,base)

import functools
int2 = functools.partial(int,base=2)	# 与上等价

方法

编码解码

'abc'.encode('ascii')	# 编码
b'abc'.decode('ascii')	# 解码

传参

'这是一串{0},它写于凌晨{1}点'.format('测试文字',2)

切片:list|tuple|str

list
从一个单位中提取部分

alist = ['jack','rose','green']
alist[0:2]						# 会取到前两个元素,也就是alist[0],alist[1]
alist[:2]						# 缩略写法,结果同上
alist[-2:-1]					# 取倒数第二元素,也就是alist[-2]
alist[-2]						# 结果同上
alist[-2:]						# 取倒数两元素,也就是alist[-2],alist[-1]

alist = list(range(100))	# 生成list:[0,1,2,..,99]
alist[0]					# 取左1
alist[-1]					# 取右1
alist[:10]					# 取前10,也就是alist[0]...alist[9]
alist[0:10]					# 同上
alist[-10:]					# 取后10,也就是alist[-10]...alist[-1]
alist[-10:-1]				# 取后10中的前9,不含alist[-1]
alist[10:20]				# 取前11-20,也就是alist[10]...alist[19]
alist[:10:2]				# 跳着取前10,步长为2,也就是alist[0],aslit[2]...alist[8]
alist[0:10:2]				# 同上
alist[:]					# 取所有数
alist[:5]					# 取前5
alist[::5]					# 跳着取所有数,步长为5,也就是alist[0],alist[5]...alist[95]

tuple

t = (0,1,2,3,4,5)
t[:3]				# 取前3

s = 'abcdefg'
s[:3]			# 取abc
s[::2]			# 取aceg

调试

try except

try:
	a()
except:
	b()
else:
	c()
finally:
	d()

成功执行

指定错误

非指定错误

开始

try

finally

except ValueError

else

类

创建类

class student:				# 创建类
	pass

class mid_student(student):	# 基于student类创建子类
	pass

jack = student()			# 使用类

创建类属性

class student:
	def __init__(self,name,score):	# __init__是必须的,使用类的第一步
		self.name = name			# 将参数传入到类'变量'
		self.score = score

# self必须

jack = student('Jack','99')			# 使用类
jack.name							# 使用类的属性

创建类方法

class student:
	def __init__(self,name,score):
		self.name = name
		self.score = score

	def print_score(self):
		print('%s:%s' % (self.name,self.score))	# 调用__init__里面的变量

jack = student('Jack','99')
jack.print_score()					# 使用类的方法,要带括号

私有化变量

class student:
	def __init__(self,name,score):
		self.__name = name			# 加下划线私有化
		self.__score = score		# 私有化可以防止外部调用引起混乱
	
	def print_score(self):
		print('%s:%s' % (self.__name,self.__score))

子类:类的类

class animal:
	def run():
		print('Animal is running')

class dog(animal):
	def eat():
		print('Dog eats meat')

d = dog()
d.run()		# 继承的类自动携带父类原有的方法	

class cat(animal):
	def run():
		print('cat is running')

c = cat()
c.run()		# 子类的同名方法会覆盖父类的方法

class mammal(animal):
	pass 

class flyable(animal):
	pass 

class bird(mammal,flyable):
	pass					# 可以有多个爸爸 并同时拥有他们的财产

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：虚拟机如何进入spark 虚拟机如何进入桌面

下一篇：javascript高级程序设计下一本看完 javascript高级程序设计最新

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

python教程 廖雪 python基础教程 廖雪峰

python教程 廖雪 python基础教程 廖雪峰

文章目录

输入输出

txt

特殊字符

基本单位:list|tuple|dict|set|generator

判断:if

循环:for|while|break|continue|Iterable,iter,Iterator

函数

自定函数

函数别名

基本单位

高阶函数:map|reduce|lambda|filter|sorted

偏函数

方法

编码解码

传参

切片:list|tuple|str

调试

try except

类

51CTO博客

python教程廖雪 python基础教程廖雪峰

python教程廖雪 python基础教程廖雪峰