注释快捷键
ctrl + (注释与取消注释）
转义
使用 r " " 代表 " " 中的不转义，
print('\ \byy') print(r'\ \byy')
>>> yy
>>>\ \byy
对于参数为路径的，为什么要带r‘’， 因为，路径中有“", ""为转义符，带上r”“，代表不转义，否则会报错
path3 = os.path.dirname(r'C:Usersviruser.v-desktopPycharmProjectshexinpracticepickle.txt')
sep
end
print（）的参数，sep：值与值得分隔符，默认为空格； end：以什么结尾
print（）默认在字符串末尾增加换行符结尾，对于输出后不想换行时，可增加：end = “”
字符串
编码
ascii ： 一个字节
unicode： 通常为2个字节，
utf - 8 ：可变长编码，字母等为一个字节，汉字通常为三个字节，生僻字等为四-六个字节
在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码
s.encode: 编码
print(b'xe4xb8xadxff'.decode('utf-8', errors='ignore')) # 忽略编码中无法被编码部分
s.decode：解码
len（s） ： 字符串长度
内置数据类型
list 、 tuper、 dict 、 set
list： 有序可变列表，可随时添加和删除元素
创建list： L1 = [1, 2, 3]
使用索引访问list，当索引超出范围时，提示indexError
tuper：有序列表，初始化后不可变
创建tuper： t1 = （1，2，3）， 定义tuper只有一个元素时，必须加一个逗号，t = （1，） （用以和数学中t =（1）区分，数学中该括号为小括号，不为元组）
dict：使用键-值存储（键不重复），具有极快的查找速度（也成为map），可添加和删除键值
当字典中key不存在时，报错提示 “key error”
判断key是否存在方法：
“key” in dict
dict.get（‘key’）
dict中的key为不可变对象（需要通过key计算位置（哈希算法));
不可变对象：字符串、整数等均可作为key，list为可变对象不能作为key
dict = {"yuyu":12, "hahau":13}
dict['bubu'] = 34
print(dict)
print('yuyu' in dict) # 使用in判断key是否存在，结果为true/false
print(dict.get("bubu")) # 使用get判断key是否存在，不存在时返回None
key = [1,2,3]
dict[key] = 'lala' # 使用列表作为可以，报错提示typeError
print(dict)
>>>
{'yuyu': 12, 'hahau': 13, 'bubu': 34}
True
34
Traceback (most recent call last):
File "C:/Users/viruser.v-desktop/PycharmProjects/hexin/practice/practice.py", line 115, in <module>
dict[key] = 'lala'
TypeError: unhashable type: 'list'
set ： 集合，无重复元素
创建set： s = set（[1，2，3]）
重复元素在set中会自动被过滤
s1 = set([1,2,3]) s2 = set([1,4,5,6,2]) s1.add(2) # 在集合中增加重复元素会被自动过滤掉 print(s1) print(s1 & s2) # 交集 print(s1 | s2) # 并集 >>> set([1, 2, 3]) set([1, 2]) set([1, 2, 3, 4, 5, 6])
内置数据类型小结：
tuple：不可变列表，代码更安全，需要对列表防止修改时，可使用tuple代替list
list：随着元素增加查找和插入的时间增加；占用空间小
dict：查找和插入速度极快，不会随着key是增加而变慢； 但需要占用大量内存
set ：与dict的唯一区别为没有存储对应的value，与dict一样不可放入可变元素（无法判断两个元素是否相等）
可变对象与不可变对象：
可变对象：list，dict，set等，对该变量操作后，对象值发生变化
不可变对象：str，对str变量操作后，实际是创建了新的变量，原变量内容不变
L1 = [1,2,3] L1.append(4) a = 'abc' b = a.replace('a', 'A') # replace替换a字符串中值,a指向的对象不变,使b指向创建的新对象'Abc' print("L1的值为:{0} a的值为:{1} b的值为:{2}".format(L1, a, b)) >>> L1的值为:[1, 2, 3, 4] a的值为:abc b的值为:Abc
函数
内置函数：
http://docs.python.org/3/library/functions.html （可查看内置函数有哪些，及内置函数的用途）
调用函数时，参数数量错误/参数类型错误均会报错：typeError，（具体错误原因查看错误信息）
print(hex(25print(hex(255)) #将255转换为16进制5)) >>> oxff
参数类型检查 ：使用内置函数：isinstance()
def my_abs(x): if x >= 0: return x else: return -x print(my_abs('a')) >>> a # 上述my_abs 的定义未对参数类型进行检查，应添加定义只允许整数和浮点数类型的参数 def my_abs(x): if not isinstance(x, (int, float)): raise TypeError('bad operand type for my_abs():{0}'.format(type(x))) if x >= 0: return x else: return -x print(my_abs('a')) >>> Traceback (most recent call last): File "C:/Users/viruser.v-desktop/PycharmProjects/hexin/practice/practice.py", line 129, in <module> print(my_abs('a')) File "C:/Users/viruser.v-desktop/PycharmProjects/hexin/practice/practice.py", line 123, in my_abs raise TypeError('bad operand type for my_abs():{0}'.format(type(x))) TypeError: bad operand type for my_abs():<type 'str'>
函数参数
位置参数：调用函数，按位置输入参数，例power（x），x就为位置参数
def power(x): # 计算x2 return x * x
默认参数： （默认参数降低调用函数的难度，对于有多个参数，其中几个参数基本不变时可采用默认参数）
def power(x,n=2): # 默认求x2,求xn时,需输入n对应的值 s = 1 while n>0: n = n -1 s = s*x return s
默认参数必须指向不可变对象
def add_end(L=[]): # 可修改 L = None L.append('end') return L print(add_end([1,2,3])) print(add_end(['x','y'])) print(add_end()) print(add_end()) # 当默认参数为可变时，定义是，L=[],首次调用时 L=['end']即L的值被改变，,即每次调用时，默认参数的值会被改变，不再是[]
>>> [1, 2, 3, 'end'] ['x', 'y', 'end'] ['end'] ['end', 'end']
可变参数：可变参数允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple
当参数已经是一个list或者tuple时，可将该list/tuper直接作为可变参数传入
def calc(*numbers): # 求 a2 + b2 + c2..... sum = 0 for n in numbers: sum = sum + n * n return sum print(calc()) print(calc(5, 6, 7)) num = [1, 2, 3, 5, 7, 8, 9] print(calc(*num)) # 将该list/tuper直接作为可变参数传入
关键字参数：允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
def person(name, age, **kw): print('name:{0};age:{1};other:{2}' .format(name, age, kw)) person("雨雨", 23, city = 'bj',score = '100') # 在python2以ascii编码，因此不能直接print（name，age），print（name，age）返回为一个元组，而name为汉字，age为数字，，统一使用ascii编码时汉字会乱码。
命名关键字参数 ：限制关键字参数的名字
def person(name, age, *, city, job): print(name, age, city, job) >>> person('Jack', 24, city='Beijing', job='Engineer') Jack 24 Beijing Engineer
>>>kw = {'city':'bj', 'score':'100'}
person("雨雨", 23, **kw)
递归函数
# coding=utf-8 """ 删除列表中相邻重复元素,例,当abbac,删除重复元素bb后,为aac,继续删除aa """ def transfer (s): m = len(s) for i in range(1, m): if s[i] == s[i-1]: s.remove(s[i]) s.remove(s[i-1]) return transfer(s) # 此处必须使用return 代表外层函数的结束,若无return代表调用函数执行完继续执行外层函数 print(s) s = ['a','b','b','a','c','a'] transfer(s)
python 特性
切片：切片可应用于list、tuper、字符串
l = [1,2,3,4] print(l[x:y:z]) #x默认为0，y默认为最后一个，z默认为1
迭代：迭代可应用于list、tuper、字典、字符串等可迭代对象上
判断对象是否可迭代 ？
list = [1,2,3,4,5] dict = {'a':1, 'b':2, 'c':3} char = ('ABC') for L in list: print(L) for i, L in enumerate(list): # 同时迭代list中的索引和值 print(i, L) for key in dict: # 迭代字典中的key print(key) for value in dict.values(): # 迭代字典中的value print(value) for key, value in dict.items(): # 同时迭代字典中的key和value print(key,value) for ch in char: print(ch)
列表生成式 ：创建list的生成式
# 生成list:1,2,3,4,5,6.... L1 = list(range(1,22)) # 生成[1*1,2*2,3*3...] L2 = [x * x for x in range(1,11)] # 生成[2*2, 4*4, 6*6..]等偶数的平方 L3 = [x * x for x in range(1,11) if x % 2 == 0] # 列出当前目录下多有文件和目录名 import os L4 = [d for d in os.listdir('.')] # 使用两个变量生成列表 d = {'x': 'A', 'y': 'B', 'z': 'C' } L5 = [m + '=' + n for m, n in d.items()] # 把list中所有字符串变成小写 L = ['Hello', 'World', 'IBM', 'Apple'] L6 = [s.lower() for s in L] # 将列表中所有大写字母变为小写,其余不变 Ln = ['Hello', 'World', 18, 'Apple', None] L7 = [s.lower() if isinstance(s,str) else s for s in Ln ]
生成器：当列表元素可通过某种算法推算出来时，可在循环过程中不断推算出后续的元素
定义生成器的两种方法：
第一种：将列表生成式中的【】变为（）
g = (x * x for x in range(10)) # 将列表生成式中的[]变成（）该g为一个生成器 # print(g.next()) # 需要获取列表的下一个数据时，不断获取g.next() ''' for n in g: # 可通过循环输出所有列表元素 print(n) ''' for n in range(0,5): #也可设定输出区间内的列表元素 print(g.next())
第二种：yield ：遇到yield时返回，下次执行从上次返回的yield语句出继续执行
# 斐波拉契数列 def fib(max): n, a, b = 0, 0, 1 while n < max: yield b a, b = b, a + b n = n + 1 ''' m = fib(10) # 创建一个generator的对象,然后不断调用next获取下一个返回值 print(next(m)) ''' for n in fib(10): # 使用循环不断调用yield print(n)
例：杨辉三角
'''杨辉三角''' def triangles(): L = [1] while True: yield(L) L.append(0) L = [L[i]+L[i-1] for i in range(len(L))] m = triangles() for t in range(10): print(m.next())
迭代器：可以被next（）函数调用并不断返回下一个值得对象成为迭代器 : Iterator
凡是可以作用于for的为可迭代对象:Iterable，如list、dict、str； 但可以通过iter（）函数获得一个Iterrator对象
m = [1,2,3] # Iterable L = [x for x in range(10)] # Iterator M = iter(m) print(M.next())