python笔记（基础）

2020.1.29 最近做了性能测试之后就没怎么具体编过程，现在是春节，但是因为疫情的原因，上班推迟，天天在家挺空闲的，所以决定温习一下。

1、字符串常用函数

Python3 字符串 | 菜鸟教程

计算字符出现次数：s = "我叫陈威".count('陈', 0, 3)   指定开始和结束下标

endswith(suffix, beg=0, end=len(string))
检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

find(str, beg=0, end=len(string))
检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1

index(str, beg=0, end=len(string))
跟find()方法一样，只不过如果str不在字符串中会报一个异常.

replace(old, new [, max])
把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。

strip([chars])

在字符串上执行 lstrip()和 rstrip()

2、列表：

Python3 列表 | 菜鸟教程

l = [1, 2, 3]l.reverse() #元素反转l.clear() #清空列表l.append(4) #追加元素
 

3、元组

元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：

4、字典 Python3 字典 | 菜鸟教程

定义：d = {key1 : value1, key2 : value2 }  #键必须是唯一的，但值则不必。

主要操作：

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典

radiansdict.items()  #返回字典中的项

radiansdict.values() #返回字典中的值

radiansdict.keys() #返回字典中的key

遍历：

for k, v in dict.items():
    print(k ,':', v)

字典键的特性
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

实例
#!/usr/bin/python3
 
dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
 
print ("dict['Name']: ", dict['Name'])
以上实例输出结果：

dict['Name']:  小菜鸟
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：

实例
#!/usr/bin/python3
 
dict = {['Name']: 'Runoob', 'Age': 7}
 
print ("dict['Name']: ", dict['Name'])

5、集合

集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

集合的相关运算：

print(a - b)     # a 和 b 的差集

print(a | b)     # a 和 b 的并集

print(a & b)     # a 和 b 的交集

print(a ^ b)     # a 和 b 中不同时存在的元素

6、for语句：

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")

如果for循环正常结束，else中语句执行。如果是break的，则不执行

7、range()：

for i in range(5):  #0 - 5序列
    print(i)

for i in range(5, 10): #5 - 10序列
    print(i)

for i in range(11, 20, 2): #步长为2
    print(i)

8、迭代器

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器：

9、if语句

实现C中的三元表达式：

a = 1
b = 2
d = b if a > b else a
print(d)

9、函数

传不可变对象和可变对象区别：

（1）传整型等不可变对象，对其进行修改，值不会变

def ChangeInt( a ):
    a = 10
 
b = 2
ChangeInt(b)
print( b ) # 结果是 2

（2）传入list等可变对象，即使不返回，对象也被修改

def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

调用函数时，如果没有传递参数，则会使用默认参数。

#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

不定长参数

（1）加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

（2）加了两个星号 ** 的参数会以字典的形式导入。

def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

匿名函数

lambda 函数的语法只包含一个语句。 lambda [arg1 [,arg2,.....argn]]:expression

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
 

10、python数据结构

Python3 数据结构 | 菜鸟教程

（1）列表、元组、集合、字典的各种操作

（2）列表推导式

列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。

每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。

比如：list = [x*x for x in range(10) if x > 5]

list = [x*y for x in range(10) if x > 5 for y in range(6)]
print(list) #长度为24， 生成4*6个数字

（3）字典推导式：{x: x**2 for x in (2, 4, 6)}

（4）遍历技巧：

同时遍历两个或更多的序列，可以使用 zip() 组合：

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
    print('What is your {0}?  It is {1}.'.format(q, a))

11、模块

一个模块只会被导入一次，不管你执行了多少次import。这样可以防止导入模块被一遍又一遍地执行。

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。

from modname import name1[, name2[, ... nameN]]

main方法：每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。

if __name__ == '__main__':

12、输入输出：Python3 输入和输出 | 菜鸟教程

（1）str.format() 的基本使用如下:

print('{}网址： "{}!"'.format('菜鸟教程', 'www.runoob.com')) #对应填充
print('{0} 和 {1}'.format('Google', 'Runoob')) #按下标填充
print('{1} 和 {0}'.format('Google', 'Runoob'))
print('{name}网址： {site}'.format(name='菜鸟教程', site='www.runoob.com')) #按参数名填充
print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob', other='Taobao'))

（2）% 操作符也可以实现字符串格式化。

print('常量 PI 的值近似为：%5.3f。' % math.pi)

（3）可选项 : 和格式标识符可以跟着字段名。 这就允许对值进行更好的格式化。 下面的例子将 Pi 保留到小数点后三位：

print('常量 PI 的值近似为： {0:.3f}。'.format(math.pi))

在 : 后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用。

print('常量 PI 的值近似为： {0:5.3f}。'.format(math.pi))
print('常量 PI 的值近似为： {0:6.3f}。'.format(math.pi))

(4)读取键盘输入 str = input("请输入：")

（5）读写文件

open() 将会返回一个 file 对象：open(filename, mode)  #mode：决定了打开文件的模式：只读，写入，追加等。常用: r只读（不加参数默认），w写入，w+读写， a追加

文件对象方法：

Python3 File 方法 | 菜鸟教程

完整的语法格式为：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:

• file: 必需，文件路径（相对或者绝对路径）。
• mode: 可选，文件打开模式
• buffering: 设置缓冲
• encoding: 一般使用utf8
• errors: 报错级别
• newline: 区分换行符
• closefd: 传入的file参数类型
• opener:

f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

f.readline() 会从文件中读取单独的一行。换行符为 '\n'。

f.readlines() 将返回该文件中包含的所有行。

如果需要进行字符编码：f = open('data.txt', 'r', encoding='utf-8')

以上三种方式的结果：

为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。

size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

以下实例假定文件 foo.txt 已存在（上面实例中已创建）：
>>> 
['为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。\n', '\n', 'size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。\n', '\n', '以下实例假定文件 foo.txt 已存在（上面实例中已创建）：']
>>> 
为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。

文件写入：f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。

pickle模块

python的pickle模块实现了基本的数据序列和反序列化。

通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

13、OS 文件/目录方法

os 模块提供了非常丰富的方法用来处理文件和目录。具体方法见下面链接：

Python3 OS 文件/目录方法 | 菜鸟教程

14、错误和异常

（1）try/except...else。else 子句将在 try 子句没有发生任何异常的时候执行。

（2）try-finally 语句无论是否发生异常都将执行最后的代码。

（3）Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。 

assert expression
等价于
if not expression:
    raise AssertionError

15、面向对象

（1）类使用实例：

#!/usr/bin/python3
"""一个简单的类实例"""
class MyClass:
    #类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用
    def __init__(self):
        print("创建了一个新类：", self)
    #类变量：类变量在整个实例化的对象中是公用的
    i = 12345
    #在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数
    #self 代表的是类的实例，代表当前对象的地址,而 self.class 则指向类本身。
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass()
x.i = 45678
y = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的属性 i 为：", y.i)
print("MyClass 类的方法 f 输出为：", x.f())
 

（2）

• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。可对父类方法进行调用或者重写，可继承一个或者多个类。格式：class sample(speaker,student):
• 子类不重写 __init__，实例化子类时，会自动调用父类定义的 __init__。

（3）属性与类方法

私有属性：__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

私有方法：__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。self.__private_methods。

私有方法或者属性只能在类内部定义方法去调用，不能直接使用实例化对象访问。类似java中只能通过getter方法访问

16、命名空间和作用域

三种命名空间：

• 内置名称（built-in names）， Python 语言内置的名称，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
• 全局名称（global names），模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。
• 局部名称（local names），函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）

命名空间查找顺序：假设我们要使用变量 runoob，则 Python 的查找顺序为：局部的命名空间去 -> 全局命名空间 -> 内置命名空间。

在一个 python 程序中，直接访问一个变量，会从内到外依次访问所有的作用域直到找到，否则会报未定义的错误。

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。

global 和 nonlocal关键字：当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)

17、python3标准库概览

（1）操作系统接口：os模块提供了不少与操作系统相关联的函数。

（2）datetime模块为日期和时间处理同时提供了简单和复杂的方法。

高级特性

1、正则表达式：Python3 正则表达式 | 菜鸟教程

re 模块使 Python 语言拥有全部的正则表达式功能。

compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。

（1）re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

re.match(pattern, string, flags=0) #

（2）re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。

两者区别：re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

（3）compile 函数

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用

import re
pattern = re.compile(r'\d+') #用于匹配至少一个数字
m = pattern.match('one12twothree34four', 3, 10) # 从下标3到10
print(m)
print(m.group()) #获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；
print(m.start(0)) #获取某个分组匹配的子串在整个字符串中的起始位置
print(m.end(0)) #获取某个分组匹配的子串在整个字符串中的结束位置
print(m.span()) # 返回 (start(group), end(group))
 

（4）findall

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

注意： match 和 search 是匹配一次 findall 匹配所有。

import re
 
pattern = re.compile(r'\d+')   # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)
 
print(result1)
print(result2)

其他特殊语法：

def bar(multiple):

    def foo(n):

        return multiple ** n

    return foo

调用后结果： bar(2)(3) == 8

9.7补充：

1.生成器：在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

2、列表推导式

列表推导式提供了从序列创建列表的简单途径。每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。

（1）单个列表元素

>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]

（2）多个列表元素

>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]

（3）加if

>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]

（4）列表值由多个元素计算得出，配合if

>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]