【笔记】廖雪峰的Python教程_语法

待我称王封你为后i 2023-02-21 14:02 2阅读 0赞

### 文章目录 ###

# 输入输出 #

输入`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 #

*  for

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}

1.  key循环

for k in d:
    	print(k)

1.  value循环

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

1.  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

1.  一般用来循环

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

1.  用来生成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

*  str

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					# 可以有多个爸爸 并同时拥有他们的财产