自学廖雪峰教程，Python学习笔记（一）

主要是对自己学习做一个笔记整理，小白可直接绕道 廖雪峰的官方网站，进行学习。

基础：

#一般函数
print("str","str1") #打印函数  输出-> str str1
input("这里是输入提示：") #输入字符串  可用 int()强转
chr(20000)  #转换字符
ord("一") #转化字符编码
bin(22) #二进制
oct(22) #八进制
hex(22) #十六进制
b'ABD'.decode('ascii') encode('ascii') # str与bytes互转 含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。
len("asdc") #字符长度
PI #π 3.1415926...
range(5) #生成的序列是从0开始小于5的整数
abs(-100) #绝对值 
max(2,3,1) #返回最大值
int(),str(),bool(),float() #类型转化
enumerate(['a','b','c']) #函数可以把一个list变成索引-元素对
"S".lower() #小写，非字符串使用会报错
isinstance("haha",str) #判断是否为字符串  

#运算符
and #和
or #或
% ： ('%2d-%.2f' % (200,33.232)) #格式化 %转义用%% 输出200-33.23  %d数字 %s字符串 %f浮点 %x十六进
& ： set([1, 2, 3]) & set([2, 3, 4]) #交集 显示{2, 3}
| ： set([1, 2, 3]) | set([2, 3, 4]) #并集 显示{1, 2, 3, 4}

#数据结构
list:#有序的集合
    list = [1,2,3,4] #直接初始化
    appen(5) #末尾添加元素
    list[3] list[-2]  #获取第四位元素 #倒数第二位  索引越界时 抛indexError
    insert(1,'J') #指定索引插入元素
    pop(2) #指定索引删除，不加索引为删除末尾
    sort() #排序
tuple：#不可变的集合
    tuple = (1,2,'a') #初始化 只有一个元素时要加逗号(1,)  空()
dict:#字典 键值对  等于Map 无序 通过key计算位置的算法称为哈希算法（Hash）
    d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} #初始化
    d['Michael'] #查询Michael的值  赋值/修改直接用 =   key不存在 报KeyError  
    d.get('Bob',-1) #get方法 key不存在返回 -1 或未指定时返回 None
    'Tracy' in d #判断键是否存在 key是不可变对象 如str,int  list是可变的
    d.pop(key) #根据键删除
set:#key的集合不存放value 无序 不能重复，重复元素在set中自动被过滤
    s = set([1, 2, 3]) #初始化
    add(key) #增加
    remove(key) #删除

#条件语句 
 if 条件1 and 条件2:
     ... #代码块
elif 条件3 or 条件4:
    ...
else :
    ... 

#循环语句
for item in list: #将集合元素进行迭代
    ...

while 条件: #while循环 
    ...

continue break #结束本轮循环  结束此循环

#函数  参数错误或类型不对报TypeError
def #声明定义函数的关键字
from abstest import my_abs #从abstest.py文件导入方法my_abs

def nop(): #pass 什么也不做 定义空函数或空代码块时
    pass

def move(i,j):
    return i+1,j+1

# -*- coding: utf-8 -*-
import math  #导入内库

def quadratic(a, b, c): #计算 一元二次方程 ax^2 + bx + c = 0  
    d = b*b - 4*a*c
    x1 = (math.sqrt(d) - b) / (2 * a) #math.sqrt 求平方根
    x2 = (0 - math.sqrt(d) - b) / (2 * a)
    return x1,x2 #可以返回多个值

x,y = quadratic(2, 3, 1) 

def power(x,n=2):#计算次方值 n默认值等于2 必选参数在前，默认参数在后 否则Python的解释器会报错  
    s = 1
    if n > 0:
        while n > 0:
            n = n - 1
            s = s * x
    elif n < 0:
        while n < 0:
            n = n + 1
            s = s * (1 / x)
    return s
def add_end(l=None)#默认参数必须指向不变对象！ 若默认l = [],后续多次调用时 l会进行改变
    if(l is None):
        l = []
    l.append("END")
    return l

def calc(*arg):# *号，0-n个参数调用是一个可变参数，arg接收的是一个tuple
    s = 0
    for num in arg:
        s = s + num * num
    return s
print(calc(1,2,3)) # 调用时可使用多个参数 简化调用  calc([1,2,3]) \ calc((1,2,3)) ==> calc(1,2,3) tuple

def fun(a,v,**kw):# ** 0-n个参数0-n个参数 是关键字参数，kw接收的是一个dict。
    pass

def fact(x) #阶乘 递归函数
    if(x <= 0) :
        return x
    if x == 1 :
        return 1
    return x * fact(x-1)
##  ===> fact(5)
##  ===> 5 * fact(4)
##  ===> 5 * (4 * fact(3))
##  ===> 5 * (4 * (3 * fact(2)))
##  ===> 5 * (4 * (3 * (2 * fact(1))))
##  ===> 5 * (4 * (3 * (2 * 1)))
##  ===> 5 * (4 * (3 * 2))
##  ===> 5 * (4 * 6)
##  ===> 5 * 24
##  ===> 120

高级特性：

1. 切片 Slice

l = [1,2,3,4,5] l = “hello word” 字符串也能使用切片
l[start​ : end : interval] 返回数组中索引 = [start,end-1] 取不到end,

interval为每间隔interval个取

l[1:5] => [2,3,4,5] ; l[-2:-1] => [4] ;l[0:0] => []
l[:3] => [1,2,3] ; l[-2:] => [4,5] ; l[:] => [1,2,3,4,5] 两端可省略
l[::2] => [1,3,5] 间隔2取一次

2. 迭代 for…in…

迭代类型 str,list,set,tuple,dict…

默认情况下，dict迭代的是key。
如果要迭代value，可以用for value in d.values()，
如果要同时迭代key和value，可以用for k, v in d.items()。

检查是否可迭代,通过collections模块的Iterable类型判断

from collections import Iterable
isinstance(obj, Iterable) # obj是否可迭代

多个变量，利用enumerate(list) 实现list用索引下标迭代

for x, y in [(1, 1), (2, 4), (3, 9)]:
     print(x, y)
for i, v in enumerate([1,2,3,4]):
    print(i,v)

3. 列表生成式

[结果 判断式 迭代式 过滤] 结果与迭代不可省略

  [x if x > 6  else  -x  for x in range(1,11)  if x%2 == 0]   ---> [-2, -4, -6, 8, 10]

4. 生成器 generator

[结果 判断式 迭代式 过滤] 结果与迭代不可省略

   g = (x if x > 6  else  -x  for x in range(1,11)  if x%2 == 0)  与列表生成式括号不同
   #直接用next调用
   next(g) --> -2
   next(g) --> -4
   ...  
   next(g) --> StopIteration    当无值时抛出异常
   #使用循环
   for n in g:
     print(n)

  # 带yield的生成器方法 generator function
  def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)
>>> o = odd() 有yield函数会变为generator
>>> next(o)  每次执行next，会返回yield出现的地方
step 1
1
>>> next(o)
step 2
3
>>> next(o)
step 3
5
>>> next(o)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

5. 迭代器 Iterator

集合数据类型，如list、tuple、dict、set、str等 是 Iterable
generator，包括生成器和带yield的generator function。 是Iterator
直接作用于for循环的对象统称为可迭代对象：Iterable，可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator 它们表示一个惰性计算的序列；(需要被计算时才被调用)。
使用isinstance()判断是否是Iterable、Iterator对象，iter()将可迭代对象Iterable变为迭代器对象Iterator

 from collections.abc import Iterator
 isinstance((x for x in range(10)), Iterator)  --> true
 isinstance([], Iterator)  --> false
 isinstance((), Iterator)  --> false
 isinstance("abc", Iterator)  --> false
 isinstance(iter("abc"), Iterator)  --> true
 
#for循环等价于
it = iter([1, 2, 3, 4, 5])
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break