Python

<font color = red>Life is short, you need Python.</font>

控制流

if语句语法：

if name ==‘Alice’：
    print（‘Hi Alice’）
else：
    print（‘False’）

elif语句语法：

name = 'alece'
age = 18
if name == 'alice':
    print("Hi")
elif age < 20:
    print("lolle")
elif age >50:
    print("mmmm")
else:
    print('true')

While语句语法：

spam = 0
while spam<5:
    print("hello")
    spam+=1

for循环和range()函数

range（）函数的开始、停止和步长

for i in range(12,16):
    print(i)

执行结果：

for i in range(0,10,2):
    print(i)

最后一个参数为步长

print(random.randint(1, 20))#随机生成一个1-20之间的数字

函数：

函数也是一个对象，对象是内存中专门存储数据的一块区域，这块区域就是一个对象，函数可以用来保存一些可执行d的代码

def语句和参数：

def hello(name):
    print('hei,'+name)
hello('ale')

不定长参数，在定义函数时，可以在形参前边加个*这样这个形参将会获得所有的实参，它会将所有实参保存到一个元组当中（装包）

def fn(*a):
    print(a)
fn(1,2,3,4)

执行结果：

如果在形参开头直接写一个*，则要求我们所有的参数必须以关键字的方式传参

def（*，a,b,c）
fn(a = 1,b = 2 , c = 3)

**的形参可以接受其他的关键字参数，他会将这写参数统一保存到一个字典中，字典的key就是参数的名。字典的value就是参数的值。

**的形参只能有一个，并且必须写到所有参数的最后

def fn(**a):
    print(a)
fn(b = 1,c = 2)

执行结果：

参数的解包（拆包）

def fn （a,b,c）
​

创建一个元组/列表都可以，字典需要。**解包

t = (10,20,30)
t = [10,20,30]

fn(*t)
fn(**t)

传递实参时，也可以在序列的类型前添加星号，这样他会自动将序列中的元素依次作为参数传递，要求序列中元素的个数必须和形参中元素的个数保持一致

def sum(*no):
    res = 0
    for n in  no:
        res += n
    print(res)
sum(1,2,3)

执行结果：

文档字符串

help（）Python中内置的函数，可以查询到python中的函数的用法

help(print)

递归：

def fn(n):
    if n == 1:
        return 1
    return n * fn(n-1)
print(fn(20))
​
​
def fn(s):
    if len(s)<2:
        return True
    elif s[0] != s[-1]:
        return False
    return fn(s[1:-1])
print(fn("hello"))

filter（）可以从序列中欧过滤出符合条件得元素，保存到新得序列中

参数：

​ 1.函数，根据函数来过滤序列（可迭代得结构）

​ 2.需要过滤得序列（可迭代得结构）

返回值：

​ 过滤后的新序列（可迭代得结构）

匿名函数lambda表达式

lambda a,b : a+b

调用：（lambda a,b : a+b）（10，30）

也可以将匿名函数赋值给一个变量

fn = lambda a,b : a+b
fn（20，30）

列表语法：

列表数据类型（类似Java数组）

spam = ["cat","dog"，"mouse".....]
spam[0] = cat
​

负数索引：例子: spam[-1] = "mouse" 拿列表最后一个值 ，依次类推

切片：就像索引 一样可以从列表中取单个值一样，切片可以获取多个值

spam = ["cat","dog","mouse","face","leg","peg"]
print(spam[0:2])
​
spam[:2]#等价与spam[0:2]
spam[0:]#等价于从第一个索引值拿到后面全部的切片值
spam[:]#拿到全部的切片值
len(spam) #返回切片长度

执行结果：

切片索引包含第一个索引值，不含第二个索引值

使用切片改变列表值

spam = ["cat","dog","mouse","face","leg","peg"]
spam[0] = "zhangsan" # 给索引为0的位置重新赋值

列表连接和列表复制

列表可以连接和复制，和字符串一样。+操作符可以连接两个列表，取得一个新列表

spam = ["cat","dog","mouse","face","leg","peg"]
spam1 =["q","2"]
spam2 = spam + spam1
print(spam2)

输出结果：

用del语句从列表中删除值

spam = ["cat","dog","mouse","face","leg","peg"]
del spam[1]
print(spam)

执行结果：

遍历列表，如果使用”+“拼接需要强制类型转换，将i转为String类型

spam = ["cat","dog","mouse","face","leg","peg"]
for i in  range(len(spam)):
    print("I的数据类型==》",i)
    print(type(i))
    print("index = >",i,"spam的值 = >"+spam[i])
    print("index = >"+str(i)+"spam的值 = >"+spam[i])

执行结果:

in和not in操作符

in和not in 用于连接两个值：一个是要在列表中查找的值，另一个是待查找的列表。

spam = ["cat","dog","mouse","face","leg","peg"]
print("cat" in spam)
返回True

spam = ["cat","dog","mouse","face","leg","peg"]
print("cat"  not in spam)
返回False

enumerate（）函数与列表一起使用

在循环每次迭代中，enymerate（）将返回两个值，一个是表中索引和表本身

for i,item in enumerate(spam):
    print(item,i)

执行结果：

random.choice(spam)#从列表中随机拿值

spam = ["cat","dog","mouse","face","leg","peg"]
random.shuffle(spam)
print(spam)

random.shuffle（）随机排序列表

用index（）方法获取列表中的索引位置，如果列表中存在重复值，就返回它第一次出现的索引位置

spam = ["cat","dog","mouse","face","leg","peg"]
print(spam.index("cat"))

执行结果：

spam = ["cat","dog","mouse","face","leg","peg"]
print(spam.index("peg", 0, 3))

执行结果：

可以指定index（）函数在列表中检索的范围，如果在该范围中有该对象，就返回该对象的索引位置，如果没有就报错提示：ValueError ：对象不在列表中

用append（）方法和insert（）方法在列表中添加值

spam = ["cat","dog","mouse","face","leg","peg"]
spam.append("张三")
print(spam)

执行结果：

注：append（）方法只能添加新值到列表的末尾,而insert（）可以添加到任意位置

spam = ["cat","dog","mouse","face","leg","peg"]
spam.insert(2,"张三")
print(spam)

用remove（）方法从列表中删除值

spam = ["cat","dog","mouse","face","leg","peg"]
spam.remove("cat")
print(spam)

执行结果：

注：如果列表中有多项相同值，使用remove（）方法只有第一次出现的值会被删除

使用sort（）方法将列表排序

spam = ["cat","dog","mouse","face","leg","peg"]
spam.sort()
print(spam)

执行结果：

也可以指定关键字reverse参数为True让sort（）排序为逆序

spam = ["cat","dog","mouse","face","leg","peg"]
spam.sort(reverse=True)
print(spam)

执行结果：

spam = ["cat","dog","mouse","face","leg","peg"]
spam.sort(key = len)#根据字符串长度进行排序
print(spam)

sort（key = int/str）int：会将列表中的值转为int进行排序 str：类似

sorted（）

使用reverse（）方法反转列表中的值

spam = ["cat","dog","mouse","face","leg","peg"]
spam.reverse()
print(spam)

执行结果：

元组数据类型

语法结构 ：eggs = （‘cat’,'moser','aa'）如果元组中只有一个值，后面必须加一个逗号，例：eggs = （'aaa',）

用list()和tuple（）函数来转换类型

list（）和tuple（）可以在列表和元组之间互相转换

例：

spam = ["cat","dog","mouse","face","leg","peg"]
eggs=tuple(spam)
print(eggs)
li = list(eggs)
print(li)

执行结果：

Python中使用ID函数获取对象的内存地址

例:

spam = ["cat","dog","mouse","face","leg","peg"]
eggs=tuple(spam)
print(id(spam))
print(id(eggs))

执行结果：

copy（）函数和deepcopy（）函数

spam = ["cat","dog","mouse","face","leg","peg"]
li = copy.copy(spam)
print(li == spam)

执行结果：

spam = ["cat","dog","mouse","face","leg","peg"]
li  = copy.deepcopy(spam)
print(li == spam)

执行结果：

字典数据类型（类似HasMap）

语法结构:person = {'name':'Bob','age':'12'}

字典的索引被称为“键”，键及其关联的值称为“键值对”

print (person['name'])输出Bob

因为字典是不排序的，所以不i能像列表那样切片

keys（）values（）和items（）方法

for循环迭代字典中的值

spam={'name':'bob','age':12}
for v in spam.values():
    print(i)

执行结果：

for循环迭代字典中的键

spam={'name':'bob','age':12}
for k in spam.keys():
    print(k)

执行结果：

for循环迭代字典中的键值

spam={'name':'bob','age':12}
for k in spam.items():
    print(k)
   

执行结果：

利用keys（）values（）items（）方法可以遍历出字典中的键、值 返回的是一个列表

例：

spam={'name':'bob','age':12}
print(spam.items())
print(spam.keys())
print(spam.values())

执行结果：

检查字典中是否存在键或值

语法：

spam={'name':'bob','age':12}
print('name' in spam.keys())

执行结果：虚拟机发的rpm包比挂载的rpm版本高 版本对不上

nss 版本高？

get（）方法

spam={'name':'bob','age':12}
print(spam.get('name','张三'))

执行结果：

如果键在字典中不存在，则返回 它的备用值

spam={'name':'bob','age':12}
print(spam.get('kk','张三'))

执行结果：

setdefault（）方法

给字典中某个键设置一个默认值，传递给该方法的第一个参数是要检查的键，第二个参数是当该键不存在时要设置的值，如果该键确实存在，那么setdefault（）方法就会返回该键的值

例：字典中不存在的键

spam={'name':'bob','age':12}
spam.setdefault("sex",'男')
print(spam)

执行结果：

字典中存在键

spam={'name':'bob','age':12}
print(spam)
print(spam.setdefault("name", '男'))

执行结果：

字符串操作

转义字符	输出为
\'	单引号
\''	双引号
\t	制表符
\n	换行符
\	倒斜杠

使用三重引号

print('''何浩东
赵智峰
‘''')

执行结果：

字符串索引和切片

字符串像列表一样。使用索引和切片。可以将字符串‘hello world’ 看成一个列表，字符串中的每一个字符都是一个项，都有对应的索引

h e l l o
0 1 2 3 4

spam = 'hello world'
print(spam[0])

执行结果：

也可以使用切片

字符串放入其他字符串

name = '何浩东'
age = 24
print('name is %s,old is %s'%(name,age))

执行结果：

python3.6中引入了f插值

name = '何浩东'
age = 24
print(f'name is {name},old is {age}')#重点是字符串前面的f

执行结果：

字符串方法upper（）、lower（）、isupper（）、islower（）

upper（）和lower（）字符串返回一个新字符串，其中原字符串的所有字母都被相应地转换为大写或小写，字符串中的非字母的非字母字符保持不变

spam = "hello world"
print(spam.upper())

执行结果：

spam = "hello world"
print(spam.isupper())

执行结果：

其余两个类似

字符串的isX（）方法：列举

​ isalpha（）方法，如果字符串只包含字母，并且非空返回True

​ isalnum（）方法如果字符串只含字母和数字,并且非空，返回True

​ isdecimal（）方法如果字符串只包含数字字符，并且非空，返回True

​ isspace（）方法如果字符串只包含空格，制表符和换行符，并且非空，返回True

​ istitle（）方法如果字符串仅包含以大写字母开头，后面都是小写字母的单词、数字或空格，返回True

字符串方法startswith()和endswith（）

​ 如果上述方法所调用的字符串以该方法传入的字符串开始或结束，是返回True 否返回False

spam = "hello world"
print(spam.endswith('world'))

执行结果：

字符串方法join（）和split（）

join（）：一个字符串列表，需要将他们连接成字符串，可以使用join（），按照什么连接字符串

例:

spam = ["cat","dog","mouse","face","leg","peg"]
print(','.join(spam))

执行结果：

​

split（）：分割字符串，返回列表

例：

spam = "hello world"
print(spam.split('h'))

执行结果：

使用partition（）方法分割字符串

partition（）可以将字符串分成分割字符串前后的文本

例:

spam = "hello world"
print(spam.partition('o'))

执行结果：

用rjust（）ljust（）和center（）方法对齐文本

spam = "hello world"
print(spam.rjust(20,'*'))
print(spam.ljust(20, '*'))
print(spam.center(20, '*')))

执行结果：

用strip（）rstrip（）和lstrip（）方法删除空白字符

spam = "              hello world                    "
​
print(spam.lstrip())
print(spam.strip())
print(spam.rstrip()

执行结果：

使用ord（）和chr（）函数的字符数值

print(ord('a'))
print(chr(65))

执行结果：

用pyperclip模块的复制粘贴字符串

pyperclip.copy('hello')
pyperclip.paste()

集合（Set）

集合和列表非常相似

​ 不同点：

​ 1.集合中只能存储 不可变对象

​ 2.集合中存储的对象是无序的（不是按照元素的插入顺序保存）

​ 3.集合中不能出现重复元素

创建集合使用{}创建集合

s = {1,2,3,4}

使用set（）函数创建集合：

​ s = set()

可以通过set()来将序列或列表转为集合

s = set([1,2,3,5,4,6,7,2])
s = set('hello')
s = set({'a':1,'b':2})#使用set（）将字典转为集合时，只包含字典中的键

集合也可以使用in 和not in ，len（）

往集合中添加元素add()：

s.add(10)

update()将集合中的元素添加到当前集合中

s.update(s1)

s1也可以是序列，可以是字典作为参数（字典只会使用Key，不会使用value）

集合的运算

在对集合进行运算时，不会影响原来的集合，而是返回一个运算结果

S = {1,2,3，4，5}
s2 = {4, 5, 6}

操作符
&	符是取交集运算符，有返回结果
|	符是取并集运算符，有返回结果
-	差集 只在A集合中有的
^	异或集：获取只一个集合中有
<=	检查一个集合是否是另一个集合的子集
<	检查一个集合是否是一个集合的真子集
>	检查一个集合是否是另一个集合的真超集
>=	检查一个集合是否是另一个集合的超集

示例语法：result = s & s2

模块

模块 是包括 Python 定义和声明的文件。文件名就是模块名加上 .py 后缀。模块的模块名（做为一个字符串）可以由全局变量 name 得到

fibo.py文件：

# Fibonacci numbers module
​
def fib(n):  # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
        print(b, end=' ')
        a, b = b, a + b
    print()
​
​
def fib2(n):  # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a + b
    return result
​

test.py文件：

import fibo
fibo.fib(100)

执行结果：

import fibo
print(fibo.fib2(100))

执行结果：

拿到模块名

import fibo
print(fibo.__name__)

执行结果：

如果打算频繁使用一个函数，你可以将它赋予一个本地变量:

import fibo
fi = fibo.fib
fi(100)

执行结果：

深入模块

模块可以导入其他的模块。一个（好的）习惯是将所有的import语句放在模块的开始（或者是脚本），这并非强制。被导入的模块名会放入当前模块的全局符号表中。import 语句的一个变体直接从被导入的模块中导入命名到本模块的语义表中。

例:

from fibo import fib, fib2
fib(100)

from fibo import *
fib(100)

出于性能考虑，每个模块在每个解释器会话中只导入一遍。因此，如果你修改了你的模块，需要重启解释器；或者，如果你就是想交互式的测试这么一个模块，可用 [imp.reload() 重新加载，例如 import imp; imp.reload(modulename)。

作为脚本来执行模块

模块中的代码会被执行，就像导入它一样，不过此时 __name__ 被设置为 "__main__"。这相当于，如果你在模块后加入如下代码:

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))

模块的搜索路径

导入一个叫 spam 的模块时，解释器先在当前目录中搜索名为 spam.py 的文件。如果没有找到的话，接着会到 sys.path 变量中给出的目录列表中查找。 sys.path变量的初始值来自如下：

• 输入脚本的目录（当前目录）。

• 环境变量PYTHONPATH 表示的目录列表中搜索

  (这和 shell 变量 PATH 具有一样的语法，即一系列目录名的列表)。

• Python 默认安装路径中搜索。

  在支持符号连接的文件系统中，输入的脚本所在的目录是符号连接指向的目录。 换句话说也就是包含符号链接的目录不会被加到目录搜索路径中。

实际上，解释器由sys.path变量指定的路径目录搜索模块，该变量初始化时默认包含了输入脚本（或者当前目录）， PYTHONPATH和安装目录。这样就允许 Python 程序了解如何修改或替换模块搜索目录。需要注意的是由于这些目录中包含有搜索路径中运行的脚本，所以这些脚本不应该和标准模块重名，否则在导入模块时 Python 会尝试把这些脚本当作模块来加载。这通常会引发错误。