廖雪峰python 学习日记

python
python 进入编辑模式
exit();退出编辑模式
import+ filename 在编辑模式下导入 filename这个py文件
python filename.py 直接运行这个py文件


print()会依次打印每个字符串，遇到逗号“,”会输出一个空格，因此，
输出的字符串是这样拼起来的
print('a','b')//a b


name = input()/*input里面可以放置提示的内容*/
wenbin
>>> name 
'wenbin'
>>>
以#开头的语句是注释
当语句以冒号:结尾时，缩进的语句视为代码块
and、or和not 与或非
python里面的空值用None表示


a = 'ABC'
print(a)#ABC
b = a
print(b)#ABC
a = 'XYZ'
print(a)#XYZ
print(b)#ABC
执行第一步 在内存中创建了一个字符串ABC  创建了一个变量a 并把a的指针指向ABC
执行第二步 创建了一个变量b 并把b的指针指向a指针指向的数据ABD
执行第三步 并把a的指针指向新的数据XYZ（b的指针指向还是原来的ABC）


在Python中，通常用全部大写的变量名表示常量；


在Python中，有两种除法，一种除法是/：
>>> 10 / 3
3.3333333333333335
/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：
>>> 9 / 3
3.0


地板除//（两个整数的除法仍然是整数）
>>> 10 // 3
3
可以得到两个整数相除的余数（%和JS一样）
>>> 10 % 3
1


Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：
>>> ord('A')
65
>>> ord('中')
20013
>>> chr(66)
'B'
>>> chr(25991)
'文'
                   **encode()和decode（）；
>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'




len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：


格式化
>>> 'Hello, %s' % 'world'
'Hello, world'
>>> 'Hi, %s, you have $%d.' % ('Michael', 1000000)
'Hi, Michael, you have $1000000.'
格式化整数和浮点数还可以指定是否补0和整数与小数的位数
>>> '%2d-%02d' % (3, 1)
' 3-01'
>>> '%.2f' % 3.1415926
'3.14'
如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串：


list列表（可以随时添加和删除其中的元素）
append（）；添加
insert(1,'wenbin');第一个参数插入的位置 第二个参数插入的数据
要删除list末尾的元素，用pop()方法
要删除指定位置的元素，用pop(i)方法，其中i是索引位置：
>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates[2]
'Tracy'
>>> classmates[-1]
'Tracy'


>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']


>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']
>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']


tuple(另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改)
所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，
就不能改成指向其他对象，但指向的这个list本身是可变的！
要定义一个只有1个元素的tuple     t = (1,)
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])




判断
if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>


input()返回的数据类型是str


循环
names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)
#Michael
#Bob
#Tracy


range()函数，可以生成一个整数序列，再通过list()函数可以转换为list
>>> list(range(5))
[0, 1, 2, 3, 4]
break语句可以在循环过程中直接退出循环，而continue语句可以提前结束本轮循环，并直接开始下一轮循环。
这两个语句通常都必须配合if语句使用。


字典
要避免key不存在的错误，有两种办法，一是通过in判断key是否存在：
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> 'Thomas' in d
False
二是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print(d.get('Thomas'))#None 因为没有'Thomas'这个key
print(d.get('Thomas'，1))#1  如果没有'Thomas'这个key 默认值是1
print(d.get('Bob', -1))#75  如果有'Bob'这个value就是他本身 而不是默认值1
要删除一个key，用pop(key)方法，对应的value也会从dict中删除：


和list比较，dict有以下几个特点：


查找和插入的速度极快，不会随着key的增加而变慢；
需要占用大量的内存，内存浪费多。
而list相反：
查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法、




set




>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}
重复元素在set中自动被过滤：


>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}


>>> s.add(4)
>>> s
{1, 2, 3, 4}


通过remove(key)方法可以删除元素：
>>> s.remove(4)
>>> s
{1, 2, 3}


>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}


x =[4, 6, 2, 1, 7, 9]
y = x[ : ] #通过分片操作将列表x的元素全部拷贝给y
不能写（ y = x）
y.sort()
print y #[1, 2, 4, 6, 7, 9]
print x #[4, 6, 2, 1, 7, 9] 




python 方法
abs();绝对值
max();最大值


int();数据类型转换 转换为整数;
float();数据类型转换 转换为浮点数;
str();数据类型转换 转换为字符串;
bool();数据类型转换 转换为True 或 False;
hex(x);将一个整数转换为一个十六进制字符串 


定义函数用def
例如
def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，
比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。
只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance()实现 isinstance(x, (int, float))
 raise TypeError('bad operand type') 扔出错误


函数可以同时返回多个值，但其实就是一个tuple。
这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、
命名关键字参数和关键字参数。
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。




尾递归防止栈溢出




python 切片
list截取
L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
L[0:3]
['Michael', 'Sarah', 'Tracy']
如果第一个索引是0，还可以省略：
 L[:3]
['Michael', 'Sarah', 'Tracy']
 L[1:3]
['Sarah', 'Tracy']
 L[-2:]
['Bob', 'Jack']
 L[-2:-1]
['Bob']
L = list(range(100)) #[0,1,......100]
前10个数，每两个取一个：
L[:10:2]
[0, 2, 4, 6, 8]


tuple也是一种list
 (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)
字符串'xxx'也可以看成是一种list
 'ABCDEFG'[:3]
'ABC'
 'ABCDEFG'[::2]
'ACEG'


python for循环（遍历）（迭代）
遍历key
>>> d = {'a': 1, 'b': 2, 'c': 3}
>>> for key in d:
...     print(key)
...
遍历value
for value in d.values():
遍历key和value
for k, v in d.items():


print([x * x for x in range(1, 11)])
#[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]


[x * x for x in range(1, 11) if x % 2 == 0]
#[4, 16, 36, 64, 100]


s='Hellow'
s.lower()#hellow  转小写
isinstance(s, str)判断s是否是字符串 是的话返回True 不是的话 返回False




http://svgtopng.com/zh/   SVG转PNG*****************


是否可迭代判断方法
from collections import Iterable
isinstance([], Iterable)
isinstance(需要判断的数据, Iterable)#True 代表可以迭代 False 表示不能迭代


可以使用isinstance()判断一个对象是否是Iterator对象
>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数：
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True
总结可迭代和 迭代器
凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
                                                  python 
     map()和reduce()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，
因此通过list()函数让它把整个序列都计算出来并返回一个list
   map
>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
   reduce
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
但是如果要把序列[1, 3, 5, 7, 9]变换成整数13579，reduce就可以派上用场：
>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579


装饰器decorator就是一个返回函数的高阶函数
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
@log
def now():
    print('2015-3-25')
>>> now()
call now():