Python学习笔记

#记得在每个执行py前加入来切换utf-8编码

# -*- coding: utf-8 -*-

#在文本编辑器中将缩进tab设置为四个空格

#当字符串中存在’‘时使用""表示字符串或者使用转义字符’ "
使用r'' 来表示’'中的字符无需转义

#’’’
‘’’
“”"
“”"可以用来表示多行字符串避免使用\n

#布尔值运算

True and False
->False
True or False
->True
not True
->False

#关于除法

#浮点数除法
9/3
->3.0
#地板除->只取整数部分
9//3
->3

python对整数没有大小限制，对浮点数也没有大小限制但是超过一定范围会显示inf（无限大）

#字符编码问题
ASC||->Unicode->UTF-8
UTF-8可变字长
Python3中用的是Unicode
使用

char（21312321）来获取字符
ord（字符）来获取整数值
\u4e2d\u6587
->'中文‘
#\u代表十六进制

str表示字符串数据类型，网路传输和磁盘保存的时候回转换成bytes

'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'.encode('utf-8')
>>>'中文'

decode()的时候可能会遇到无法转译的字符报错，此时用b' '.decode('utf-8',errors='ignore')来略过错误字符

len（b'ABC')
>>>3
>len('中文')
>>>2
#len()用于求字符串中有多少个字符
当len（b'  '）的时候则是多少个字节
utf-8中汉子3字节，英文字母1字节

#为了避免乱码，请始终使用utf-8转换

每一个.py中，理应有如下代码
#! /usr/bin/env python3
# -*- coding:utf-8 -*-
第一行是告诉Linux/OS X这是个python可执行文件，第二行告诉解释器按utf-8读取

#关于格式化字符串
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

format（）的运用
'Hello ,{0},成绩提升了「%s:.1f}%'.formart('小明',17.21321321321)
>>>‘Hello，小明，成绩提升了17.1%’

#list
类似c中的数组array

classmate=['John','Mike',Nancy']
->classmate
>>>[...]

classmate.append('sdsadsa')
#添加到list尾部
classmate.insert(1，‘Jack’）
#插入到...位置'

关于循环
for 变量 in 数组
循环

while循环

#break跳出循环
#continue跳过本次循环

关于dic和set
#dic再其他语言中又城map，采用键-值的存储结构（Key-value）

d['Jack']=23

#用于检测key是否存在的方法一
'Jack' in d
>>>True
#用于检测key值是否存在的方法二
d.get('Jack',不存在key)
>>>23
#默认返回default==None，可以自定义
print ('Value=%r') % d.get('Nike',-1)
>>>-1

#删除dic  ->d.pop()
d.pop('Jack')
#连value和key一起删除
#key再dic的存放顺序和输入key的顺序没关系
#dic为不可变对象
#dic为空间换时间->hash表算法

关于set
set可以看做无序和无重复元素的集合
set中重复的元素会被不显示
set（）需要一个list

a=set([1,2,3])
b=set([2,3,4])

a&b
>>>{2,3}
a|b
>>>{1,2,3,4}

a.add(4)
a.remove(3)
#set的插入与删除

###set，dic中无法放入可变对象

##关于可变对象
str为不可变对象
不论是
a=‘abc’
a.sort()
a.replace(‘a’,‘A’)
都不改版’abc’，而是创建了另外一个字符串，再用a指向它。

关于函数
eg: abs()取绝对值函数

return两个值

x,y=sadas(asdjsa,asdasd)
print x,y
>>> asdasd sadasda
r=sadas(asdjsa,asdasd)
print r
>>>(asdasd,sadasda)
#其实返回的事一个tuple，再依次赋值给两个变量

定义函数时的默认变量
eg：

def mianji(r,Pi=3.14)
	asdasa
	dasd
	return S
#但是这个方法有个bug默认参数是list时不好用
def add_end(L=[]):
    L.append('END')
    return L
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']
#更改一下函数
def add_end(L=None):
    if L is None:
        L = []
    L.append('END')
    return L
    #即可

可变参数*numbers
表示list或者tuple

关键字参数
和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：

extra = {‘city’: ‘Beijing’, ‘job’: ‘Engineer’}
person(‘Jack’, 24, city=extra[‘city’], job=extra[‘job’])
name: Jack age: 24 other: {‘city’: ‘Beijing’, ‘job’: ‘Engineer’}
当然，上面复杂的调用可以用简化的写法：

extra = {‘city’: ‘Beijing’, ‘job’: ‘Engineer’}
person(‘Jack’, 24, **extra)
name: Jack age: 24 other: {‘city’: ‘Beijing’, ‘job’: ‘Engineer’}
extra表示把extra这个dict的所有key-value用关键字参数传入到函数的kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：

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

###关于 *args 和**kw

python中*args **kw表示的是什么，*args是非关键字参数，用于元组，**kw是关键字参数，用于字典。

def foo(*args, **kwargs):    
    print ('args = ', args    )
    print ('kwargs = ', kwargs  )  
    print ('---------------------------------------')
if __name__ == '__main__':
   foo(1,2,3,4)
   foo(a=1,b=2,c=3)
   foo(1,2,3,4, a=1,b=2,c=3)
   foo('a', 1, None, a=1, b='2', c=3)

运行结果：

args =  (1, 2, 3, 4)
kwargs =  {}
---------------------------------------
args =  ()
kwargs =  {'a': 1, 'b': 2, 'c': 3}
---------------------------------------
args =  (1, 2, 3, 4)
kwargs =  {'a': 1, 'b': 2, 'c': 3}
---------------------------------------
args =  ('a', 1, None)
kwargs =  {'a': 1, 'b': '2', 'c': 3}
---------------------------------------

可以看到，这两个是python中的可变参数。args表示任何多个无名参数，它是一个tuple*；kw表示关键字参数，它是一个dict。并且同时使用args和kw时，必须*args参数列要在kw前，*像foo(a=1, b=’2’, c=3, a’, 1, None, )这样调用的话，会提示语法错误“SyntaxError: non-keyword arg after keyword arg”。

另：if name == ‘main’:代码的作用：

一个python的文件有两种使用的方法，第一是直接作为脚本执行，第二是import到其他的python脚本中被调用（模块重用）执行。因此if name == ‘main’: 的作用就是控制这两种情况执行代码的过程，在if name == ‘main’: 下的代码只有在第一种情况下（即文件作为脚本直接执行）才会被执行，而import到其他脚本中是不会被执行的。

在上面的例子程序中，如果程序被写成 foo.py，在命令行，执行python foo.py 时，输出：

args =  (1, 2, 3, 4)
kwargs =  {}
---------------------------------------
args =  ()
kwargs =  {'a': 1, 'b': 2, 'c': 3}
---------------------------------------
args =  (1, 2, 3, 4)
kwargs =  {'a': 1, 'b': 2, 'c': 3}
---------------------------------------
args =  ('a', 1, None)
kwargs =  {'a': 1, 'b': '2', 'c': 3}
---------------------------------------

而在python环境下， 执行from foo import foo 时，则只执行了if name == ‘main‘:之前的代码， 需要输入foo(1,2,3)才有输出：

args =  (1, 2, 3)
kwargs =  {}
---------------------------------------

但如果程序去掉if name == ‘main‘:这句代码，被写成foo1.py
再执行 from foo1 import foo 时，则得到

args =  (1, 2, 3, 4)
kwargs =  {}
---------------------------------------
args =  ()
kwargs =  {'a': 1, 'b': 2, 'c': 3}
---------------------------------------
args =  (1, 2, 3, 4)
kwargs =  {'a': 1, 'b': 2, 'c': 3}
---------------------------------------
args =  ('a', 1, None)
kwargs =  {'a': 1, 'b': '2', 'c': 3}
---------------------------------------

关于递归
栈（stack）的大小不是无限的，为了避免栈溢出，使用尾递归，即函数返回时，调用自身本身，且return语句不包含表达式。
（但是比较坑的一点是，python标准的解释器并没有对尾递归做出优化，所以任何递归结构都可能造成栈溢出）

关于切片（slice）
取list L[]的一部分

L[0:3]
#取0，1，2不包括3

关于迭代
使用for循环进行遍历，目标可以使str、tuple，list
注意，对dic迭代时，

for key in d
#对key迭代
for value in d.value()
#对value迭代
for k,v in d.items()
#对二者同时迭代

#如何判断对象是否可以迭代呢，这里我们要引collection中的Iterable类型判断

from collection import Iterable
isinstance(....  ,Iterable)
>>>True

#把list,tuple,str有下标的迭代（类似c中的for）

for i,value in enumerate(['a','b','c'])
	print（i，value）
	>>>0 a
			1,b
			2c

关于列表生成式
如果需要得到一个1-10的list

list(range(1,11))

但如果是要得到11，22…呢？

[x*x for x in range(1-10)  ]
>>>[1,4,9,...,100]
#还可以加上条件
[x*x for x in range(1-10) if x%2 == 0]

#还可以使用两层循环
[m+n for m in range (1-10) for n in range (1-10)]