|
Python是脚本语言
脚本语言(Scripting language)是电脑编程语言。以简单的方式快速完成某些复杂的事情通常是创造脚本语言的重要原则，基于这项原则，使得脚本语言通常比 C语言、C++语言 或 Java 之类的系统编程语言要简单容易。
一个脚本可以使得本来要用键盘进行的相互式操作自动化。一个Shell脚本主要由原本需要在命令行输入的命令组成，或在一个文本编辑器中，用户可以使用脚本来把一些常用的操作组合成一组串行。主要用来书写这种脚本的语言叫做脚本语言。很多脚本语言实际上已经超过简单的用户命令串行的指令，还可以编写更复杂的程序。
IDLE是一个Python Shell，shell的意思就是“外壳”，基本上来说，就是一个通过键入文本与程序交互的途径！像我们Windows那个cmd窗口，像Linux那个黑乎乎的命令窗口，他们都是shell，利用他们，我们就可以给操作系统下达命令。同样的，我们可以利用IDLE这个shell与Python进行互动。
想具体查看某个 BIF（built in function内置函数） 的功能 help（ ）让系统告诉你 括号里面的东西有什么作用
C:\Users\HUAWEI>conda activate base #进入环境
(base) C:\Users\HUAWEI>python
Python 3.8.5 (default, Sep 3 2020, 21:29:08) [MSC v.1916 64 bit (AMD64)] :: Anaconda, Inc. on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> dir(__builtins__) #显示内置函数和内置对象，其中小写的就是 BIF
[ 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max'....]
>>> exit() （or Ctrl-Z）
(base) C:\Users\HUAWEI>conda deactivate #退出环境
C:\Users\HUAWEI>
基础知识
提前预热一下，不懂的后面还会讲解。
a='abc'
isinstance(a,str)
优先级： 幂运算>正负号>加减乘除> == != > >= >逻辑运算符
not and or 逻辑运算符3<4<5 ture
三元操作符 a=x if x<y else y
pthon内置的数字类型有整数，实数，复数
对于实数的运算可能会有一定的误差，尽量避免在实数直接进行相等性测试，而是以两者之差的绝对值是否足够小作为是否相等的依据
>>> 0.4-0.3
0.10000000000000003
>>> 0.4-0.3==0.1
False
>>> abs(0.4-0.3-0.1)<1e-6
True
abs(x)
x.imag
x.real
x.conjugate
python中字符也是字符串
'1,2,3'+'4,5'
[1,2,3]+[4,5]
*除了乘法运算，还可以表示序列的重复
[1,2,3]*3
'abc'*3
python不支持++ --运算 ++i解释为两个正号，i值不变，i++直接报错，所以直接i+=1,i-=1用着就行
>>> bin(555)
'0b1000101011'
>>> oct(555)
'0o1053'
>>> hex(555)
'0x22b'
ord()<->chr() 返回单个字符的Unicode码<->返回Unicode的字符
eval()用来计算字符串的值，有时候可以实现类型转换 eval('9')
用户不管输入什么内容，input()一律作为字符串对待，顾我们需要对输入内容进行转化
>>> x=input('please')
please[1,2,3]
>>> x
'[1,2,3]'
>>> list(x)
['[', '1', ',', '2', ',', '3', ']']
>>> eval(x)
[1, 2, 3]
python中的正无穷或负无穷
使用float (“inf”)或float ("-inf")来表示。 这里有点特殊，写成：float (“inf”)，float (“INF”)或者float (‘Inf’)都是可以的。 当涉及 > 和 < 比较时，所有数都比无穷小float ("-inf")大，所有数都比无穷大float (“inf”)小。
print(float('inf'))
print(complex('inf'))
print(float('inf')*0)
print(math.isnan(float('nan')))
print(float('inf')*float('-inf'))
inf
(inf+0j)
nan
True
assert 断言 此关键字后面条件为假，程序自动崩溃报错
int()函数
它可以将给定的数值转换成十进制整数，转换时可以指定以几进制的方式解析给定的数。例如：
int(``"123"``) ``123` `
int``(``"10101"``, base``=``2``) ``21` `
`int``(``"abc12c"``, base``=``13``) ``4053672
max,min也可以支持key参数
print(max(['2','111'],key=len)) #111
l = [[random.randint(1, 10) for i in range(5)] for j in range(10)] # 包含生成10个子列表，每个列表有5个介于[1,10]的整数的列表
print(len(l))
print(max(l, key=sum))
print(max(l,key=lambda x:x[1])) #按第二个大小排序
print(max(l,key=lambda x:(x[1],x[3])))# 先按第二个数比，若比不出来，再按第四个数比
**sorted()**和reversed()一样都是python的内置函数，与list.sort(),list.reverse()不一样，她两是list自带函数
reduce()
将接受两个参数的函数以迭代累积的方式从左到右依次作用到一个序列或迭代器对象的所有元素上
```python
from functools import reduce
print(reduce(lambda x,y:x+y,[1,2,3,4])) #10 (1+2)+3....
random.sample()
从指定序列中随机获取指定长度的片断并随机排列，结果以列表的形式返回.choice() 方法返回一个列表，元组或字符串的随机项。randrange() 方法返回指定递增基数集合中的一个随机数，基数默认值为1。
print "randrange(100, 1000, 2) : ", random.randrange(100, 1000, 2)
eval 方法能使字符串本身的引号去掉，保留字符的原本属性。
**exec():
不同于eval ()函数只能执行计算数学表达式的结果的功能，exec ()能够动态地执行复杂的Python代码
x = 'name = "Bill"\nprint(name)'
exec(x)
>>>exec 'print "Hello World"'
Hello World
exec（source，globals=None，locals=None）
列表
dir(list)
.insert
.extend
.remove(x)
.pop()
.clear()
del list[1]
len(列表名)
.count(x)
.sort()
.reverse()
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> tuple(_)
(0, 1, 2, 3, 4)
>>> list(str([1,2,3]))
['[', '1', ',', ' ', '2', ',', ' ', '3', ']']
>>> e=list(range(11))
>>> e
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> sorted(e,reverse=True)
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> sorted(e,key=lambda i:(len(str(i))))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> sorted(e,key=lambda i:(len(str(i))),reverse=True)
[10, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list({'a':3,'b':4}))
print(list({'a':3,'b':4}.items()))
print(list({'a':3,'b':4}.values()))
x=list()
del x
print(x)
a[ : ] 可以拷贝列表
元组
元组是轻量级列表，常量级列表。元组的访问速度比列表快，还具有安全性、
若创建一个只有一个元素的元组 ,在后面加逗号 eg：tuple=(1,) tuple=1, 甚至不用括号>>> 8*（8，）得到（8，8，8，8，8，8，8，8）
temp=（‘哈哈哈’，‘不不不’，‘时代的’，‘十大）
temp=temp[:2]+('sdsad',)+temp[2:]
temp
(‘哈哈哈’，‘不不不’，'sdsad',‘时代的’，‘十大）
.index("")
set('111222333')
>>> import keyword 关键字
>>> print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
导入模块后，在模块名称后敲.再按tab键，会显示该模块所有函数
>>> import random
>>> random.Tab
random.BPF random.betavariate( random.lognormvariate( random.setstate(
>>> random.randint(1,3)
1
random.random()
random.randrange(1,100)
光标置于函数调用处ctrl+q可查看函数注释
函数之前最好空两行
def ahb():
"""打招呼"""
print("hello python")
ahb()|ctrl+q
对象
print(range(100))
zip() 打包 压缩
把多个可迭代对象对应位置上的元素压缩到一起，返回一个可迭代的zip对象
原型：zip([iterable,…]) 参数iterable为可迭代对象，该函数返回一个以元组为元素的列表（换种说法：将多个迭代器取元素组合成一个新的迭代器），第i个元组包含每个参数列表的第i个元素，
import numpy as np
a=[1,2,3,4,5]
b=(1,2,3,4,5)
c=np.arange(5)
d="zhang"
zz=zip(a,b,c,d)
print(list(zz))
$ python3
>>> a = map(abs, [1, 2, -3])
>>> a
<map object at 0x100707ed0>
>>> list(a)
>>>[1,2,3]
$ python2
>>> a = map(abs, [1, 2, -3])
>>> a
[1, 2, 3]
zz=zip(a)
m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
n = [[2, 2, 2], [3, 3, 3], [4, 4, 4]]
print([x*y for a, b in zip(m, n) for x, y in zip(a, b)])
print([x+y for a, b in zip(m, n) for x, y in zip(a, b)])
a=[1,2,3,4,5]
b=(1,2,3,4,)
d="zhang"
zz=zip(a,b,d)
x, y, z = zip(*zz)
print(x)
print(y)
print(z)
a=dict(zip('1234','abcd'))
enumerate()用来枚举*可迭代对象*中的元素
每个元素都是包含索引和值的元组
print(enumerate([1,2,3]))
>>> a=[1,2,3,4,5]
>>> list(enumerate(a))
[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]
>>> list(enumerate(['abc','aaa']))
[(0, 'abc'), (1, 'aaa')]
>>> list(enumerate('aaa','bbb'))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object cannot be interpreted as an integer
>>> list(enumerate(('aaa','bbb')))
[(0, 'aaa'), (1, 'bbb')]
map()映射函数
把一个函数依次映射到序列的每个元素上，并且返回一个可以迭代的map对象，原序列不修改
print(map(str, range(5)))
print(list(map(str, range(5))))
def add5(v):
return v + 5
print(list(map(add5, [1, 2, 3])))
def add2(x, y):
return x + y
print(list(map(add2, [2, 2, 2], [3, 3, 3])))
a,b=map(int,input('请输入两个数字').split())
filter()过滤函数
将单参数函数作用到序列上，返回使得函数返回为True的元素组成的filter对象。
print(filter(None,[1,2,3,False]))
print(list(filter(None,[1,2,3,False]))
print(list(filter(lambda x:x.isalnum(),['1','a','asa','?'])))
reversed()
reversed()是python自带的一个方法，准确说，应该是一个类；
在经过reversed()的作用之后，返回的是一个把序列值经过反转之后的迭代器，所以，需要通过遍历，或者List,或者next()等方法，获取作用后的值；
a="asdf"
print(''.join(reversed(a)))
print(tuple(reversed(a)))
print(list(reversed(a)))
range()
该函数返回具有惰性求值特点的range（）对象,[start,stop)内以step为步长的整数
模块
在模块中定义的全局变量，函数都是模块能够提供给外界直接使用的工具
模块的导入顺序：标准库，扩展库，自定义库
要引入自己创建的库，项目右键，new个dictionary，里面写库
pip 库名 安装库或者setting里 project interpreter的+，搜索需要安装的库，install package
小tips
ctrl+？多层注释，与取消注释，还有进入typora源代码功能
.pyc 是编译过的文件，二进制文件
—属性—
name
可以识别程序的使用方式
若作为模块导入，__name__属性的值自动设置为模块名，如果作为程序导入，__name__属性值被自动设置为字符串"main"
def main():
if __name__=="__main__":
print("this program is run directly")
elif __name__=="hello":
print("this program is used as a module")
main()
获取对象类型
1、type()函数·
>>> type(123)
<class 'int'>
>>> type(123)==int
True
>>> type(None)
<class 'NoneType'>
>>> type(abs)
<class 'builtin_function_or_method'>
>>> import types
>>> type(abs)==types.BuiltinFunctionType
True
>>> type(lambda x:x)==types.LambdaType
True
2、isinstance()函数
明确class的继承关系，type()不方便。
>>> isinstance([1,2,3],(list,tuple))
True
>>>isinstance(animal,Dog)
False
>>>isinstance(dog,Dog)
True
>>>isinstance(dog,Animal)
True
3、dir()函数
获得一个对象的所有属性和方法使用dir()函数，返回一个list
列表生成式
[n+1 for n in range(3)]
list=['a','b','c']
['app_%s'%n for n in list]
[n for n in range(3) if n%2==0]
[s for s in list1 if s.endswith('.txt')]
[i for i in lista if i in listb]
[i for i in lista if i not in listb and (i%2==1)]
[m+n for m in 'abc' for n in 'xyz']
[i for first in vector for i in first]
from random import randint
x=[randint(1,10) for i in range(20)]
print(x)
m=max(x)
y=[index for index,value in enumerate(x) if value==m]
print(y)
[8, 3, 7, 9, 6, 8, 3, 6, 9, 9, 4, 9, 7, 6, 5, 5, 8, 2, 1, 9]
[3, 8, 9, 11, 19]
[(x,y) for x in [1,2,3] for y in [8,9]]
[(x,y) for x in [1,2,3] if x==1 for y in [3,4] if x!=y]
生成器表达式
通过列表生成式，直接创建一个列表，如果创建一个很大的列表浪费了很大的空间，而我们只需要访问前面几个元素，那后面都浪费了，所以要用到生成器。
生成器表达式的结果是一个生成器对象，具有惰性求值的特点，只在需要的时候生成新元素，比列表推导式更高效。
使用生成器对象的方法：根据需要转化为列表或元组，或者生成器对象的____next____()方法或内置函数next()进行遍历或者for循环。
只能从前往后正向访问每个元素，不能再次访问已访问过的元素，也不支持下标访问元素，遍历结束后若要重新访问就要重新创建生成器对象。
g=(x*x for x in range(3))
next(g)
g=(i for i in range(3))
print(g)
print(next(g,'没下一个了'))
print(next(g,'没下一个了'))
print(next(g,'没下一个了'))
print(next(g,'没下一个了'))
<generator object <genexpr> at 0x0000022794B06580>
0
1
2
没下一个了
for n in g:
print(n)
def factor(max_num):
factor_list = []
n = 2
while n<max_num:
find = False
for f in factor_list:
if n % f == 0:
find = True
break
if not find:
factor_list.append(n)
yield n
n+=1
def feb(max_num):
n_1 = 1
n_2 = 1
n = 0
while n<max_num:
if n == 0 or n == 1:
yield 1
n += 1
else:
yield n_1 + n_2
new_n_2 = n_1
n_1 = n_1 + n_2
n_2 = new_n_2
n += 1
g = feb(20)
for n in g:
print(n)
迭代器
- 迭代器访问与
for循环访问非常相似，但是也有不同之处。对于支持随机访问的数据结构如元组和列表，迭代器并无优势。因为迭代器在访问的时候会丢失数据索引值，但是如果遇到无法随机访问的数据结构如集合时，迭代器是唯一访问元素的方式； - 迭代器仅仅在访问到某个元素时才使用该元素。在这之前，元素可以不存在，所以迭代器很适用于迭代一些无法预先知道元素总数的巨大的集合；
- 迭代器提供了一个统一的访问集合的接口，定义
iter()方法对象，就可以使用迭代器访问。
可直接作用于for循环的数据类型如list、tuple、dict等统称为可迭代对象:Iterable。使用isinstance()可以判断一个对象是否是可迭代对象。例如：
from collections import Iterable
result = isinstance([],Iterable)
print(result)
result = isinstance((),Iterable)
print(result)
result = isinstance('python',Iterable)
print(result)
True
True
True
可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator。next()函数访问每一个对象，直到对象访问完毕，返回一个StopIteration异常。使用isinstance()可以判断一个对象是否是**Iterator对象**。例如：
from collections import Iterator
result = isinstance([],Iterator)
print(result)
result = isinstance((),Iterator)
print(result)
result = isinstance((x for x in range(10)),Iterator)
print(result)
FalseFalseTrue
所有的Iterable都可以通过iter()函数转化为Iterator。
序列解包
x,y,z=range(3)
x,y,z=map(str,range(3))
for k,v in zip(['a','b'],[1,2]):
print(k,v)
x,y,z=[1,2,3]
x,y,z={'a':1,'b':2,'c':3}
x,y,z={'a':1,'b':2,'c':3}.items()
x,y,z={'a':1,'b':2,'c':3}.values()
x,y,z='abc'
函数
形参：位置参数，默认值参数，可变长度参数
实参：关键参数
def demo(a,b,c=1):
print(a,b,c)
seq=[1,2,3]
demo(*seq)
dict={1:'a',2:'b',3:'c'}
demo(*dict)
def demo1(*args):
print(args)
demo1(1,2,3,3,4)
dict={1:'a',2:'b',3:'c'}
demo1(*dict)
def demo1(*args):
print(args)
def demo(a,b,c):
print(a,b,c)
def demo2(**kwargs):
print(kwargs)
dict = {'a': 1, 'b': 2, 'c': 3}
demo1(*dict)
demo(**dict)
demo2(**dict)
输出：('a', 'b', 'c')
1 2 3
{'a': 1, 'b': 2, 'c': 3}
字符串
utf8所有字符都是一个字节,
注意字符串是不可变的，任意的修改只是返回新的，本来字符串都没有改变。
str.format()
是字符串的格式化方法
print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
print('{:.2f}'.format(3.1415))
print("{1} {0} {1}".format("hello", "world"))
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
print('网站名：{0[name]},地址{0[url]}'.format(site))
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))
print("网站名：{0[0]}, 地址 {1[1]}{2[1]}".format(my_list,my_list,my_list))
class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value))
print("For only {price:.2f} dollars!".format(price = 49))
2、进阶用法
（1）< （默认）左对齐、> 右对齐、^ 中间对齐、= （只用于数字）在小数点后进行补齐
（2）取位数“{:4s}”、"{:.2f}"等
print('{:10s} and {:>10s}'.format('hello', 'world'))
print('{:^10s} and {:^10s}'.format('hello', 'world'))
print('{0} is {0:>10.2f}'.format(1.123))
hello and world
hello and world
1.123 is 1.12
3、多个格式化
‘b’ - 二进制。将数字以2为基数进行输出。
‘c’ - 字符。在打印之前将整数转换成对应的Unicode字符串。
‘d’ - 十进制整数。将数字以10为基数进行输出。
‘o’ - 八进制。将数字以8为基数进行输出。
‘x’ - 十六进制。将数字以16为基数进行输出，9以上的位数用小写字母。
‘e’ - 幂符号。用科学计数法打印数字。用’e’表示幂。
‘g’ - 一般格式。将数值以fixed-point格式输出。当数值特别大的时候，用幂形式打印。
‘n’ - 数字。当值为整数时和’d’相同，值为浮点数时和’g’相同。不同的是它会根据区域设置插入数字分隔符。
‘%’ - 百分数。将数值乘以100然后以fixed-point(‘f’)格式打印，值后面会有一个百分号。
>>> print('{0:b}'.format(3))
11
>>> print('{:c}'.format(65))
A
>>> print('{:d}'.format(20))
20
>>> print('{:o}'.format(20))
24
>>> print('{:x}'.format(20))
14
>>> print('{:e}'.format(20))
2.000000e+01
>>> print('{:g}'.format(20.1))
20.1
>>> print('{:f}'.format(20))
20.000000
>>> print('{:n}'.format(20))
20
>>> print('{:%}'.format(20))
2000.000000%
name='fzh'
print(f'my name sji{name}')
print(r'wsb\n\t')
f'{1+2}'
>>>'3'
x=1
print(f'{x+1=}')
encode()和decode()函数
bytes.decode(encoding=“utf-8”, errors=“strict”)decode() 方法以指定的编码格式解码 bytes 对象。默认编码为 ‘utf-8’。会返回新的编码后的值，不会改变自身，因为字符串是不可变类型。
encode和decode分别指编码和解码。在python中，Unicode类型是作为编码的基础类型，Unicode不是编码格式，而是字符集。这个字符集包含了世界上目前所有的符号。
errors – 设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeError。 其他可能得值有 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值。
>>> u = '中文'
>>> str1 = u.encode('gb2312')
>>> print(str1)
b'\xd6\xd0\xce\xc4'
>>> u1 = str1.decode('gb2312')
>>> print('u1')
'中文'
>>> u2 = str1.decode('utf-8')
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xd6 in position 0: invalid continuation byte
>>>"hello".encode("hex")
'68656c6c6f'
str.islower()、str.isspace()
1、字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True 。str. issupper()相反
2、空白符包含：空格、制表符(\t)、换行(\n)、回车(\r）等，空串不算空白符。
print('\t\r\n '.isspace())
print(''.isspace())
join(),ljust(),rjust(),center()
后三个返回指定宽度的新字符串
>>> '-'.join('菜鸟教程')
'菜-鸟-教-程'
>>>print('菜鸟教程'.ljust(6，'*'))
'菜鸟教程**'
>>>'菜鸟教程'.ljust(3,'*')
'菜鸟教程'
print('我爱中国'.center(6,'*'))
find(),rfind(),index(),rindex(),count(),split(),rsplit(),partition(),rpartition()
1，2是用来查找字符串在另一个字符串指定范围（默认整个字符串）首次和最后一次出现的位置，不存在则返回-1。3,4和1,2差不多，就是找不到会报错。5返回字符串在另一个字符串出现的次数，不存在则返回0。6,7以指定字符为分隔符，从字符串从左到右（从右到左）分割成为多个字符串，返回分割结果的列表。8，9是分成三部分。
s = '2001-4-5'
print(s.split('-'))
print(s.partition('-'))
print(s.rpartition('-'))
print(list(map(int, s.split('-'))))
print(s.split('-',1))
s='\n\na\t b \n c'
print(s.split())
s='\t \t a b \t'
print(s.split('\t'))
x='a bb c '
print(''.join(x.split()))
addr = "123@163.com"
print(addr.split('@'))
usr, web = addr.split('@')
strtemp='ab2b3n5n2n67mm4n2'
print(len(strtemp.split('n'))-1)
replace(),maketrans(),translate()
s='abcasbca'
print(s.replace('a','我爱中国'))
table = ''.maketrans('ab','#@')
print(s.translate(table))
我爱中国bc我爱中国sbc我爱中国
s.isdigit、isdecimal 和 s.isnumeric 区别
isdigit()
True: Unicode数字，byte数字（单字节），全角数字（双字节）
False: 汉字数字，罗马数字，小数
Error: 无
isdecimal()
True: Unicode数字，，全角数字（双字节）
False: 罗马数字，汉字数字，小数
Error: byte数字（单字节）
isnumeric()
True: Unicode 数字，全角数字（双字节），汉字数字
False: 小数，罗马数字
Error: byte数字（单字节）
num = "1"
num.isdigit()
num.isdecimal()
num.isnumeric()
num = "1"
num.isdigit()
num.isdecimal()
num.isnumeric()
num = b"1"
num.isdigit()
num.isdecimal()
num.isnumeric()
num = "IV"
num.isdigit()
num.isdecimal()
num.isnumeric()
num = "四"
num.isdigit()
num.isdecimal()
num.isnumeric()
print(“转换为二进制为：”, bin(dec))
print(“转换为八进制为：”, oct(dec))
print(“转换为十六进制为：”, hex(dec))
print( c + " 的ASCII 码为", ord?)
print( a , " 对应的字符为", chr(a))
items()以列表返回可遍历的元组数组
>>> params = {"a":"1", "b":"2", "c":"3"}
>>> ["%s=%s" % (k, v) for k, v in params.items()]
['a=1', 'c=3', 'b=2']
>>> ";".join(["%s=%s" % (k, v) for k, v in params.items()])
'a=1;c=3;b=2'
利用re模块分割含有多种分割符的字符串
strip()、rstrip()、lstrip()、startswith()、endswith()
来分割前缀和网址。 两侧，右侧，左侧 s.strip(‘a’)
s="beautiful is better"
print(s.endswith('er'))
print(s.endswith('er',10))
import os
[filename for filename in os.listdir(r'D:\\') if filename.endswith(('.jpg','.gif'))]
字符串内置函数
x='我爱 中国'
print(len(x))
print(max(x))
print(min(x))
print(list(zip(x,x)))
print(sorted(x))
print(x)
print(''.join(reversed(x)))
print(enumerate(x))
print('3+4')
a=3
b=4
print(eval('a+b'))
5
爱
[('我', '我'), ('爱', '爱'), (' ', ' '), ('中', '中'), ('国', '国')]
[' ', '中', '国', '我', '爱']
我爱 中国
国中 爱我
<enumerate object at 0x000002205F5A3B40>
3+4
7
字符串常量
string模块包含了我们常用的一些常量字符串：
- 大小写字母：
string.ascii_letters - 小写字母：
string.ascii_lowercase - 大写字母：
string.ascii_uppercase - 数字0-9：
string.digits - 十六进制数字：
string.hexdigits - 常见特殊符号：
string.punctuation - 看起来像空格的字符：
string.whitespace
这可以是表示一条或者多条python语句的字符串，也可以是compile（）返回的代码对象，globals必须是一个字典，而locals可以是任何映射，{用help查的}
创建二维列表
a=[[1,2],[3,4]]
a=[]
for i in range(3):
a.append([])
for j in range(3):
a[i].append(i*3+j+1)
a=[ [i*3+j for j in range (1,4)] for i in range(3)]
# 正则表达式
使用预定义的模式去匹配一类具有共同特征的字符串
函数参数
-
默认参数要放在所有必选参数的后面； -
默认参数必须指向不变对象。 -
可变长度参数在定义函数时有两种形式，*，**，前者用来接收多个位置参数并将其放在一个元组中，后者接收多个关键字参数并将其放在字典中。 def a(**p):
for item in p.items:
print(item)
>>>a(b=1,c=2,d=3)
可变参数
在有些情况下，我们在定义函数的时候，还不能确定函数应该包含多少个参数，这时我们可以使用可变参数，可变参数就是传入的参数数量是可变的。例如：
def plus(*numbers):
add = 0
for i in numbers:
add += i
return(add)
d1 = plus(1,2,3)
d2 = plus(1,2,3,4)
d3 = plus(1,3,5,7,9)
d4 = plus()
print(d1)print(d2)print(d3)print(d4)
输出结果：
6
10
25
在上面的例子中，numbers就是一个可变参数，可变参数前面加一个标识符*。在函数内部，可变参数numbers接收到的值是一个tuple。我们在调用参数是可变参数的函数时，可以给该函数传递任意个数的参数，包括0个参数。
关键字参数
可变参数允许我们在调用函数时传入任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许我们传入任意个含参数名的参数，这些关键字参数在函数调用时自动组装为一个dict。也就是说，关键字参数将长度任意的键-值对，作为参数传递给函数。例如：
def plus(**kw):
return kw
d1 = plus()
x=1
d2 = plus(x=1)
x=1,y=2
d3 = plus(x=1, y=2)
print(d1)print(d2)print(d3)
输出结果：
{}{'x': 1}{'x': 1, 'y': 2}
在上面的例子中，kw就是一个关键字参数，关键字参数前面加**表示。关键字参数可以扩展函数功能，使传递参数过程更为简便。例如：
def plus(x,y,z):
return x+y+z
dict = {'x':1, 'y':2, 'z':3}
dd = plus(dict['x'],dict['y'],dict['z'])
输出结果：
6
但在上述例子中，将字典中的值向plus函数中传递参数的方法过于累赘，可以采取关键字参数的方法。例如：
def plus(x,y,z):
return x+y+z
dict = {'x':1, 'y':2, 'z':3}
dd = plus(**dict)
输出结果：
6
使用关键字参数**dict的方法，可以大大提高参数传递的效率。
参数组合
我们在函数定义过程中，可以同时用到必选参数、默认参数、可变参数、关键字参数中的一种或几种。但是需要特别注意的是，这四种参数在使用的过程中是有顺序的，顺序依次应该是必选参数、默认参数、可变参数和关键字参数。例如：
def plus(x, y, z=0, *args, **kw):
print('x=',x)
print('y=',y)
print('z=',z)
print('args=',args) p
rint('kw=',kw)
plus(1,2)
输出结果：
x= 1y= 2z= 0args= ()kw= {}
上面这个例子中，向plus函数中传入了两个必选参数1和2。必选参数必须得提供值，但是默认参数、可变参数和关键字参数可以不用提供值，我们还可以给默认参数、可变参数和关键字参数传递值。例如：
def plus(x, y, z=0, *args, **kw):
print('x=',x)
print('y=',y)
print('z=',z)
print('args=',args)
print('kw=',kw)
plus(1,2,3,4,5,6)
print('\n')
plus(1,2,3,4,5,6,k=7,m=8)
输出结果：
x= 1y= 2z= 3args= (4, 5, 6)kw= {}x= 1y= 2z= 3args= (4, 5, 6)kw= {'k': 7, 'm': 8}
小结
- 不同类型的参数是有顺序的，依次是必选参数、默认参数、可变参数和关键字参数；
- 默认参数一定要用不可变对象，用可变对象容易产生逻辑错误；
*args表示的是可变参数，*args接收的是一个元组；**kw表示的是关键字参数，**kw接收的是一个字典。
接下来总结一些排序算法，参考了菜鸟教程和一些博文，没给出代码请大家自行搜索。
排序算法
冒泡排序（Bubble Sort）
arr = [3, 2, 5, 6, 1]
def bubble_sort(arr):
for i in range(1,len(arr)):
for j in range(len(arr)-i):
if arr[j]>arr[j+1]:
arr[j],arr[j+1]=arr[j+1],arr[j]
归并排序（Merge Sort）
归并排序，是创建在归并操作上的一种有效的排序算法。算法是采用分治法（Divide and Conquer）的一个非常典型的应用，且各层分治递归可以同时进行。归并排序思路简单，速度仅次于快速排序，为稳定排序算法，一般用于对总体无序，但是各子项相对有序的数列。
快速排序（Quick Sort）
def quit_sort(arr, low, high):
if low >= high:
return arr
i = low
j = high
pivot = arr[i]
while (i < j):
while (i < j and arr[j] > pivot):
j -= 1
if i<j:
arr[i] = arr[j]
i += 1
while (i < j and arr[i] < pivot):
i += 1
if i<j:
arr[j] = arr[i]
j -= 1
arr[i] = pivot
quit_sort(arr, low, j - 1)
quit_sort(arr, j + 1, high)
return arr
low = 0
high = len(arr) - 1
quit_sort(arr, low, high)
print(arr)
插入排序（Insertion Sort）
通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。
def insertionSort(arr):
for i in range(len(arr)):
preIndex = i-1
current = arr[i]
while preIndex >= 0 and arr[preIndex] > current:
arr[preIndex+1] = arr[preIndex]
preIndex-=1
arr[preIndex+1] = current
return arr
print(insertionSort(arr))
希尔排序（Shell Sort）
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
- 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
- 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；
def shellSort(arr):
import math
gap=1
while(gap < len(arr)/3):
gap = gap*3+1
while gap > 0:
for i in range(gap,len(arr)):
temp = arr[i]
j = i-gap
while j >=0 and arr[j] > temp:
arr[j+gap]=arr[j]
j-=gap
arr[j+gap] = temp
gap = math.floor(gap/3)
return arr
桶排序（Bucket Sort）
基数排序（Radix Sort）
堆排序（Heap Sort）
选择排序（Selection Sort）
def findsmall(arr):
smallest = arr[0]
smallest_index = 0
for i in range(1, len(arr)):
if arr[i] < smallest:
smallest = arr[i]
smallest_index = i
return smallest_index
def selection_Sort(arr):
newArr=[]
for i in range(len(arr)):
smallest_index=findsmall(arr)
newArr.append(arr.pop(smallest_index))
return newArr
print(selection_Sort(arr))
计数排序（Counting Sort）
|