Python学习笔记

---

Q: print(“decimal hex chr {0:^30}”.format(“name”))里 {0: ^ 30}是什么意思
A：这种用法属于Python的格式化输出字符：

1. {0:^30}中的0是一个序号，表示格式化输出的第0个字符，依次累加；
2. {0:^30}中的30表示输出宽度约束为30个字符；
3. {0:^30}中的 ^ 表示输出时右对齐，若宽度小于字符串的实际宽度，以实际宽度输出

Q: print(（"{0}：{1：.2f}".format(“圆周率”，3.14159))输出是什么
A：圆周率：3.14 因为“.2”的意思是四舍五入到保留两位小数点，f是指浮点数

Q: 若希望得到一个跨越多行的字符串，该如何实现?
A：

1. 使用多个换行符
2. 使用三重引号字符串（""“内容”""）

Q: 如果字符串内容中需要出现单引号或双引号，该如何实现?
A： 1. 使用转义符号（\）对字符串中的引号进行转义，这样Python就知道这个引号是直接输出的

eg. ‘Let’s go’ 输出结果为 “Let’s go”

2. 用上不同的引号表示字符串

eg. “Let’s go” 输出结果为 “Let’s go”

ps. 反斜杠（\）和后边的字符（n）恰好转义之后构成了换行符（\n）；在字符串前边加一个英文字母r就是使用原始字符串。
eg.

>>>string = r'C:\now'
>>>string
C:\\now'
>>>print(string)
C:\now

Q: 如何生成随机数?
A：

import random
random.randint(1,10) # 随机获取一个1~10的整数

ps. random.choice()方法可以从一个非空的序列中随机获取一个元素，从而实现具有抽奖功能的程序
Python区分整型和浮点型的唯一方式就是看有没有小数点

Q: 5 > 3 <4是什么意思
A：在Python中5 > 3 <4被解释为5 > 3 and 3 <4

Q: 如何生成一个数字序列(可迭代对象)
A：使用range()函数，其有三种用法，但其参数只能是整数
range(stop) # 生成从0到stop的数字序列
range(start, stop) # 生成 [start,stop) 的数字序列
range(start, stop, step) # 生成 [start,stop) 的数字序列，每个元素之间的间隔为step
ps. step一般情况下默认是1，但也可正可负
list是将可迭代对象以列表的形式展示出来

>>> list(range(5,10))
[5,6,7,8,9]

Q: 下列代码输出结果为

>>>eggs = ["鸡蛋", "鸭蛋", "鹅蛋","铁蛋"]
>>>e = ["鸡蛋", ["鸭蛋", "鹅蛋", "加拿大企鹅蛋"],"铁蛋"]
>>>eggs[-1]
>>>e[1][2]

A：“铁蛋”，因为当索引号为负值时，表示从列表的末尾反向索引
“加拿大企鹅蛋” , 两次索引是获得内部子列表的元素

---

基础知识

• Python中使用空白字符表示缩进。一般每缩进一次，使用4个空白字符。

类型转换

与之紧密相关的函数有int()、float()、str()
注意点：如果是浮点数转换为整数，Python会把小数点后的数据直接砍掉，而不是四舍五入！！

>>>c=5.99
>>>d=int(c)
>>>c,d
(5.99,5)

用type()函数可知关于类型的信息
同理，isinstance()这个BIF来判断变量的类型

>>>a="hello world"
>>>isinstance(a,str) # 第一个参数是待确定类型的数据，第二个是指定的一个数据类型
True # 表示类型一致
>>>isinstance(520,float)
False # 表示类型不一致

操作符

算术操作符： + - * / % ** //

a +=1         # a =a+1
b -=3         # b =b-3
c *=5         # c =c*5
d /=8         # d =d/8

%为求余数，eg. 5 % 2 = 1
//为地板除法，计算结果取比商小的最大整型数
**为幂运算操作符，eg. 3 **2 表示3的2次幂

>>>3//2
1
>>>3.0//2
1.0

使用地板除法，无论是整型还是浮点型，都将舍弃小数部分

>>>-5**2
-25
>>>5**-2
0.04

幂运算操作符比其左侧的一元操作符优先级高，比其右侧的一元操作符优先级低

比较操作符：< <= > >= == !=

>>>'a'>'b'
False

比较操作符根据表达式的值的真假返回布尔类型值

逻辑操作符： and or not

三元操作符语法：

a = x if 条件 else y

表示当条件为真的时候，a被赋值为x，否则被赋值为y

在程序做测试的时候，用assert这个关键字很好用！！
【一般当需要确保程序中的某个条件一定为真才能让程序正常工作的话】
eg. assert 3 > 4

pass是占位语句，表示不做任何事情

for循环语句语法：
for 变量 in 可迭代对象：
循环体

>>>for each in "FISK":
    print(each)
 F
 I
 S
 K

跳出循环的语句

1. break语句→跳出循环
2. continue语句→跳出本轮循环并开始下一轮循环

列表

• 索引-1对应最后一个元素，-2对应于最后一个元素的前一个元素。
• 使用切片不仅可以访问某个值，还可以访问列表的子列表（部分列表）；eg.a[0:2]表示获取索引为0到2（不包括2！！）的元素

向列表添加元素

1. 添加一个元素，则使用**append()**方法

>>> number = [0,1,2]
>>> number.append(8)
>>> number
[0,1,2,8]

2. 同时添加多个元素，则使用**extend()**方法

>>> number = [0,1,2]
>>> number.extend([7,8])
>>> number
[0,1,2,7,8]

• extend()事实上是使用一个列表来扩充另一个列表，所以其参数是另一个列表
• append() 和extend() 都是往列表的末尾添加数据
• insert() 是可往列表的任意位置插入元素
  ps. insert方法中代表位置的第一个还支持负数，表示与列表末尾的相对距离

>>> number = [0,1,2]
>>> number.insert(0，9) # 在第一个位置插入9
>>> number
[9，0,1,2]

在python列表中，第一个位置的索引值是0，第二个是1，第三个是2，依次类推…

从列表删除元素

1. remove()→需指定一个待删除的元素
2. pop()→删除指定位置的元素，若无指定位置则默认最后一个元素
3. del→可用来擅长某个元素，也可用来删除整个变量

列表切片

list2 = []
for i in range(-200,0):
   list2.append(list[i]) # 表示取出列表最后200个元素

列表切片第三个参数为步长，默认值是1

• list[::-1] #相当于把整个列表翻转过来
  eg.[1,2,3]变成[3，2，1]
• list[::2] # 表示从头到尾间隔为2取数
  ps. 上述这些切片操作都是获得列表加工后的拷贝，并不会影响到原有列表的结构
• del 会直接作用于原始列表

一些常用操作符
加号（+）也叫连接操作符

>>> list1 = [123,456]
>>> list2 = [234,123]
>>> list3 = list1 + list2
>>> list3
[123,456,234,123]

乘号（*）也叫重复操作符

>>> list = ["fish"]
>>> list*3
["fish","fish","fish"]

几个常用的方法
count() 作用是统计某个元素在列表中出现的次数
index() 作用是返回某个元素在列表中第一次出现的索引值
reserve() 作用是将整个列表原地翻转
sort() 作用是对列表元素进行从小到大的排序

元组

• 元组只可读，不可写
• 创建列表用的是中括号，创建元组大部分时候使用的是小括号
  eg. tuple = (1,2,3,4,5,6)
• 若元组中只包含一个元素，需在该元素后加一个逗号来实现
  eg. tuple1 = (52,)

字符串

几个常用的方法
casefold() 作用是将字符串中所有的英文字母修改为小写

>>> str = "Fish"
>>> str.casefold()
"fish"

count(sub[,start[,end]]) 作用是统计sub元素在字符串中出现的次数，可选参数start和end表示查找的范围

index(sub[,start[,end]]) 和 find(sub[,start[,end]]) 作用是返回某个元素在字符串中第一次出现的索引值；若没有找到，则index()方法会显示ValueError，find()方法会返回-1

replace(old,new[,count]) 作用是将字符串中的old参数指定的字符串替换成new参数指定的字符串

split(sep= None,maxsplit=-1) 作用是拆分字符串
其中sep用于指定多个参数之间的分隔符

>>> str = "肖申克的救赎/1994年/9.6分/美国"
>>> str.split(sep="/")
["肖申克的救赎"，"1994年"，"9.6分"，"美国"]

join(iterable) 作用是拼接字符串

>>> str1 = ["肖申克的救赎"，"1994年"，"9.6分"，"美国"]
>>> '-'.join(str1)
"肖申克的救赎-1994年-9.6分-美国"
>>> '/'.join(str1)
"肖申克的救赎/1994年/9.6分/美国"

ps. 程序员更喜欢用join()方法代替加号（+）来拼接字符串

表1 Python 格式化符号及含义

符号	含义
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e
%g	根据值的大小决定使用%f或%e
%G	作用同%g

>>> "%f用科学计数法表示为：%e" % (149000,149000)
"149000.000000用科学计数法表示为：1.49e+5"

表2 格式化操作符的辅助命令

符号	含义
m.n	m显示的是最小总宽度，n是小数点后的位数
-	结果左对齐
+	在正数前面显示加号（+）
#	在八进制数前面显示’0o’，在十六进制数前面显示’0x’或0X’
0	显示的数字前面填充’0’代替空格

函数

在Python中创建一个函数用def关键字，在函数名后面要加上一对小括号。
如果返回了多个值，Python默认是以元组的形式进行打包，也可以利用列表将多种类型的值打包到一块儿在返回

>>> def test():
   return 1,3.14,"小" #若是利用列表，则写成return [1,3.14,"小"]
>>> test()
(1,3.14,"小") #列表返回的为[1,3.14,"小"]

函数文档

其作用是描述该函数的功能及一些注意事项，函数的文档字符串可以通过特殊属性__doc__ 获取

>>> def exchangeRate(dollar):
    """
    功能：汇率转换，美元→人民币
    汇率：6.54
    日期：2018-06-25
    """
    return dollar*6.54
>>> print(exchangeRate.__doc__)
    功能：汇率转换
    汇率：6.54
    日期：2018-06-25

参数

• 传入实参时若用关键字参数明确指定形参的变量名，则参数之间就不存在先后顺序
  【关键字参数：在传入实参时明确指定形参的变量名】
• 在定义函数时，位置参数必须在默认参数前，否则会出错
  eg.def watchmovie(name=“I”,girlfriend) 此时位置参数girlfriend就在默认参数name之后，运行则会报错
  【默认参数：有为参数指定默认的值；位置参数：在定义函数时已经把参数的名字和位置确定下来的参数】
• 若在定义函数时，实参个数不确定，形参就可以使用收集参数（可变参数），即在参数前面加个星号（*）
  ps.Python就是把标志为收集参数的参数们打包成一个元组tuple

def test(*params):
   print("有%d个参数" % len(params))
   print("第二个参数是：" , params[1])
   print(type(params))
   
test("fish","1","23")
# 输出结果是 
# 有3个参数
# 第二个参数是1
# <class 'tuple'>

星号(*）在形参中的作用是将多个参数打包成一个元组的形式进行存储，而在实参中则起到解包的作用；两个星号是Python的另一个收集方式，但却是将参数们打包成字典的形式。

>>> name = "Fish"
>>> print(*name)
F i s h

变量

1. 局部变量
2. 全局变量

• 定义在函数内部的变量是局部变量，其作用范围只能在函数的内部生效，不能在函数外被引用。
• 若在函数内部试图修改全局变量的值，那么会使用屏蔽机制，即会创建一个新的局部变量替代（名字与全局变量相同），但真正的全局变量是不变的。若一定要修改全局变量，则需先写一行代码" global 全局变量"

对于嵌套函数，内部函数整个作用域都在外部函数之内，内部函数可以引用外部函数的局部变量。

函数式编程

函数式编程就是用函数（计算）来表示程序，用函数的组合来表达程序组合的思维方式。

1. lambda
   用此关键字来创建匿名函数

>>>def funX(x)
   return lambda y : x * y

>>> temp = funX(8)
>>> temp(5)
40

2. filter()
   filter()函数是一个过滤器，其作用是在海量的数据里面提取出有用的信息
   语法：filter(function or None, iterable)
   若第一个参数是一个函数的话，则将第二个可迭代对象里的每一个元素作为函数的参数进行计算，把返回True的值筛选出来；若第一个参数是 None，则直接将第二个参数中为True的值筛选出来。

Eg1.

>>> temp = filter(None,[1,0,False,True])
>>> list(temp)
[1,True]

Eg2.

>>>def odd(x):
      return x % 2
>>>temp = filter(odd,range(10))
>>>list(temp)
[1,3,5,7,9]  

换成函数式编程即为

>>>list(filter(lambda x : x % 2, range(10))
[1,3,5,7,9]  

3. map()
   语法：map(func, *iterables)
   将可迭代对象的每一个元素作为函数的参数进行运算加工，直到可迭代序列将每个元素都加工完毕。

>>>list(map(lambda x : x * 2, range(10))
[0,2,4,6,8,10,,12,14,16,18] 

若map()第二个参数是收集参数，则会将所有可迭代对象中依次取一个元素组成一个元组，传递给func，若可迭代对象的长度不一致，则以较短的迭代结束为止。

>>>list(map(lambda x， y : x + y, [1,3,5],[10,30,50,66,88]))
[11,33,55] 

递归

从原理上说就是函数调用自身的行为。每次函数的调用都需要进行压栈、弹栈、保存和恢复寄存器的栈操作，故是非常消耗时间和空间的。
ps.若是编写网络爬虫工具，需要自行设置递归的深度限制
方法如下：

>>>Import sys
>>>sys.setrecursionlimit(10000) # 将递归深度限制设置为一万层

若设置的值太大，程序也可能会崩溃，这时可通过Ctrl+C快捷键让Python强制停止。

字典

• python中字典也被称为哈希(hash)，或者被称为关系数组。
• 字典是python中唯一的映射类型，由“键”和“值”共同构成，每一对键值组合称为“项”。
• 字典的键必须独一无二，但值则不必。值可以取任何数据类型，但必须是不可变的，如字符串、数或元组。
• 有别于序列，字典不支持拼接和重复操作
• 字典不允许同一个键出现两次，若同一个键被赋值两次，后一个值会被记住

声明空字典，直接用大括号即可：
eg. empty = { }

也可用dict（）内置函数来创建字典

>>> dict1 = dict((('F',70),('i',105),('s',115)))
>>> dict1
{'F':70,'i':105,'s':115}

dict（）函数的参数可以是一个序列，但不能是多个，所以要打包成一个元组（或列表）序列。
还可以通过具有映射关系的参数来创建字典：

>>> dict1 = dict(F=70,i=105,s=115)
>>> dict1
{'F':70,'i':105,'s':115}
>>> dict1['i']
105
>>> dict1['s']='13'
>>> dict1
'F':70,'i':105,'s':13

还有一种创建方法，直接给字典的键赋值，若键已存在，则改写其对应的值；若不存在，则创建一个新的键并赋值，加在原来的最后。
eg. dict1[‘x’] = 88

下面列举的五种方法都是创建同样的字典

>>> a = dict(one=1,two=2,three=3)
>>> b = {'one':1,'two':2,'three':3}
>>> c = dict(zip(['one','two','three'],[1,2,3]))
>>> d = dict([('two',2),('one',1),('three',3)])
>>> e = dict({'three':3,'one':1,'two':2})

各种内置方法

1. fromkeys(seq[,value])
   用于创建并返回一个新的字典，第一个参数是字典的键，第二个是传入键对应的值，默认为None
   

2. keys()、values()、items()

3. get(key[,default])
   
   字典是采用哈希方法一对一找到成员，而序列是采取迭代 方式逐个对比。注意字典中查找的是key而不是值，但在序列中查找的是元素的值而不是元素的索引。

4. copy()

5. pop(key[,default])和popitem()
   pop（）是给定key弹出对应的值，而popitem（）是弹出一个项。

6. setdefault(key[,default])
   setdefault(）在字典中找不到对应的key时会自动添加，其值默认是None。

7. update([other])

集合

• 在python3中如果用大括号括起一堆数字但没有体现出映射关系，那么就会认为这堆数据是一个集合而不是映射。

>>> num = {1,2,3,4,5}
>>> type(num)
<class 'set'>

• 集合在python中最大特点是唯一
• 集合会自动将重复的数据删除

>>> num = {1,2,3,4,5，4，3，2，1}
>>> num
{1,2,3,4,5}

• 集合是无序的，也就是不能通过去索引集合中的某一个元素

1.创建集合
（1）直接把一堆元素用大括号括起来
（2）用set()内置函数→将列表转为集合

>>> list = [1,2,3,4,5，4，3，2，1,0]
>>> set1 = set(list)
>>> list1 = list(set1)
>>> list1
>[0,1,2,3,4,5]

定义不可变集合【集合中的数据具有稳定性】，可使用frozenset()函数，就是把元素给frozen起来

文件

ctrl+s快捷键保存数据

文件对象方法

ps.1个中文字符占用2个字节的空间;
如果要写入文件，要确保之前的打开模式有‘w’或’a’，否则会出错。

文件系统

模块在使用前需要先使用import语句导入模块。
1.OS模块
2.OS.path模块

类

使用class关键字来定义类，类要遵循下述格式

class 类名：
    def __init__(self, 参数, ...): #构造函数
        ...
    def 方法名1(self, 参数, ...): #方法1
        ...
    def 方法名2(self, 参数, ...): #方法2
        ...

构造函数只有在生成类的实例时被调用一次，self是指自身的实例。可通过在self后面添加属性名来生成或访问实例变量。