python语法

Python中默认的编码格式是 ASCII 格式，在没修改编码格式时无法正确打印汉字，所以在读取中文时会报错。

解决方法为只要在文件开头加入 # -- coding: UTF-8 -- 或者 # coding=utf-8 就行了

注意：# coding=utf-8 的 = 号两边不要空格。

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
print( "你好，世界" )

数据类型
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）

a, b, c = 1, 2, "runoob"
>>> a = 111
>>> isinstance(a, int)
True
>>>

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；

第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

10 // 3 == 3
9 / 3 == 3.0

range()
len()
hex()
isinstance()
def
try: ‘执行内容’ except ‘报错名称’: ‘遇到当前错误时报的错’

def calc(*numbers):
    sum = 0
# type(numbers) (,) tuple
    for n in numbers:
        sum = sum + n * n
       
    return sum
def person(name, age, **kw):
# type(kw) {} dict
	print('name:', name, 'age:', age, 'other:', kw)
def f1(a, b, c=0, * , d , *args, **kw):
a, b, c=0, * 这个星号 命名关键字参数 如果我要给d这个形参赋值时 f1(1, 1, 0, d=1 )
*和**都代表可变参数 
**d会把给这个函数传递的 key=value 转化到该dict中的key:value
*会把剩余的参数转化为tuple
尽量不要一起过多的使用 用多 可读性不高
def fun(a,b,*,c,**d):
    print(a,b,c,d) # 1 2 3 {'d': 311, 'aa': 123}
fun(1,2,d =311,c=3,aa=123)

def move(n,a,b,c):
    if n==1:
        print(a,'-->',c)   #如果只有一个盘子，直接从a柱移动到c柱
    else: 
        move(n-1,a,c,b)    #将a柱上的n-1个盘子通过c柱移动到b柱
        print(a,'-->',c)   #移动完n-1个盘子之后，a柱剩下的最大盘子直接从a柱移到c柱
        move(n-1,b,a,c)    #b柱上的n-1个盘子通过a柱移动到c柱
move(3,'a','b','c')

其实汉诺塔问题一般不要去自己在脑海里想n个柱子每一步的移动方式（尝试过，脑子爆炸了），最主要的就是把最大的盘子和剩下的n-1个盘子当成两个独立的整体去思考，这样一来思路就清晰多了

然后再将n-1个盘子进行细化（因为n-1个盘子其中也有最大的那个盘子），这样一来递归逻辑就形成了

from collections import Iterable
isinstance('aassc',Iterable) # 返回是否可迭代
for (x,y) in ((1,2),(2,32)):
    print(x,y)
# 1 2
# 2 32

list生成器
条件写在前面的话要 if else 都出现
条件写在后面的话只能出现if

[x if x%2 == 0 else -x for x in range(1,11) ]
# [-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]
[x for x in range(1,11) if x%2==0]
# [2, 4, 6, 8, 10]
[x if x%2 == 0 for x in range(1,11) ]
# File "<stdin>", line 1
[x for x in range(1,11) if x%2==0 else -x]
# File "<stdin>", line 1

1、生成器
和列表（list）生成器差不多 写法上把 [] 换成()

(x if x%2 == 0 else -x for x in range(1,11))

区别的话一个生成的是list 一个生成的是迭代器 （generator）
特性

[x if x%2 == 0 else -x for x in range(1,11) ]
# [-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]
a = (x if x%2 == 0 else -x for x in range(1,11))
next(a) # -1
next(a) #  2
next(a) # -3

2、生成器
另一种创造生成器的方法 要使用yield这个关键字 和js中的一样 就是next的用法不同

def fid(max):
	n,a,b = 0,0,1
	while i < max:
		yield b
		a,b = b,a + b;
		n = n + 1;
a = fid(4)
next(a) # 1
next(a) # 1
next(a) # 2
next(a) # 3
next(a) # StopIteration会报错

# 杨辉三角
def yhs(max):
    n,a = 1,[1]
    while n < max:
        yield a
        a = [1] + [ a[i] + a[i + 1 ] for i in range(len(a)-1) ] + [1]
        n = n + 1
a = yhs(4)

print(next(a))
print(next(a))
print(next(a))
print(next(a))

3、第三种

a = iter([1,2,3])
print(next(a))
print(next(a))
print(next(a))

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

高级语法

map() 和 reduce()
map可以直接用
reduce需要引入functools
map会返回一个map的对象 可以使用list()转化为列表
reduce会返回一个具体的值 （原始类型的值）

def f(x):
	return x * x
list(map(f,[1,2,3,4,5,6]))
# [1,4,9,16,25,36]

# 引入reduce
from functools import reduce
def add(x,y):
	return x + y
# reduce中的第一个参数是一个函数这个函数必须要有两个参数不然会报错
reduce(add,list(map(f,[1,2,3,4,5])))
# 55 

lambda

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

L = list(filter(is_odd, range(1, 20)))
L = list(filter(lambda x:x%2 == 1, range(1, 20)))

sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
# L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
# def by_name(t):
#     # return 
#     return t[0][0].lower()
# def by_score(t):
#     return t[1]

# L2 = sorted(L, key=by_score)
# print(L2)

nonlocal global

python中的 没有专门的变量声明表达式 在有些场景使用的时候系统不知道是要使用声明过的变量 还是要重新声明所以在变量在跨作用域使用时就会报错
nonlocal 可以使用其他作用域的变量
global可以使用全局中的变量

@修饰符

相对于为每个函数都拓展一个相同的功能

def log(func):
    def warpper(*arg,**k):
        return func(arg,k)
    return warpper
@log
def now(a,b):
	print('%s,%s'%a%b)
	print('执行片段')

now(1,2)
# 1,2
# 执行片段
效果相当于now =log(now) now(1,2)
看上去没有什么区别 使用起来确实也没有什么区别
下面就有区别了
def log(name):
	def decorator(func):
	    def warpper(*arg,**k):
	    	print(func.__name__)
	        return func(arg,k)
	    return warpper
    return decorator
@log('exec')
def now(a,b):
	print('%s,%s'%a%b)
	print('执行片段')

now(1,2)
now = log('exec')(now)
now(1,2)
# now
# 1,2
# 执行片段
# warpper
# now
# (1, 2),{}
# 执行片段
函数对象有一个__name__属性，可以拿到函数的名字：
__name__内容会不同 在部分场景可能会出错 我一个菜鸟刚刚开始学也不知道哪里会错

可能会有人想着用warpper.__name__ = func.__name__
但是官方有方法
import functools

def log(name):
	def decorator(func):
		@functools.wraps(func)
	    def warpper(*arg,**k):
	    	print(func.__name__)
	        return func(arg,k)
	    return warpper
    return decorator
@log('exec')
def now(a,b):
	print('%s,%s'%a%b)
	print('执行片段')

偏函数

简化代码用

int2 = functools.partial(int, base=2)
print(int2('1000000'))
# 64
def int2(x,base=2):
	return int(x,base)
效果一样

args = (10, 5, 6, 71111111111)
max1 = functools.partial(max, *args)
print(max1(1,6,69,9456,6)) 
# 71111111111
def ceshi(*arg):
    print(arg)
    return arg 
ceshi = functools.partial(ceshi,  1,  2)
print(ceshi(1,1,1))

def ceshi(**arg):
    print(arg)
    return arg 
ceshi = functools.partial(ceshi,  a = 1,  b = 2)
print(ceshi(a = 4 , b =4))