您的位置：首页 > 理论基础 > 计算机网络

网络爬虫及面试中必须掌握的python基础知识（二）

2018-03-18 23:20 671 查看

python的基本运算符
什么是运算符？类似于5+7=12、12-4=8、3*9=27、1/4=0.25。
python算术运算符：

运算符	描述	实例
+	加-两个对象相加（数字、字符串、列表、元组）	3+2输出 5"a"+"b" 输出 "ab"
-	减-一个数减去另一个数或集合的差集	9-1输出 8{1,2,3}-{2}输出{1,3}
*	乘- 两个数相乘或是返回一个被重复若干次的的对象（字符串，列表，元组）	45输出20[0,1]2输出[0,1,0,1]
/	除-两个数相除	5/2输出2.5
//	整除-返回商的整数部分	5//2输出2
%	取模-返回除法的余数	5%2输出1
**	幂-返回x的y次幂	3**2输出9

python比较运算符：

运算符	描述	实例
==	等于-比较对象是否相等	5==3返回False
！=	不等于-比较两个对象是否不相等	'a'!='b' 返回True
>	大于-返回x是否大于y	8>5返回True
<	小于-返回x是否小于y	7<3 返回False
>=	大于等于-返回x是否大于等于y	3>=2 返回True
<=	小于等于-返回x是否小于等于y	5<=3返回False

注：布尔值True和False等价于整数1和0。
python赋值运算符：

运算符	描述	实例
=	简单的赋值运算符	c=a+b将a+b的运算结果赋值为c
+=	加法赋值运算符	b+=a等价于b=b+a
-=	减法赋值运算符	b-=a等价于b=b-a
*=	乘法赋值运算符	b=a等价于b=ba
/=	除法赋值运算符	b/=a等价于b
%=	取模赋值运算符	b%=a等价于b=b%a
**=	幂赋值运算符	b=等价于b=ba
//=	取整除运算符	b//=a等价于b=b//a

python位运算符:

运算符	描述	实例
&	按位与运算符：参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0	1&1为11&0为0
\|	按位或运算符：只要对应的两个二进制位有一个为1时，结果位就为1	1\|0返回10\|0返回0
^	按位异或运算符：当两个对应的二进制位相异时，结果为1	1^0返回11^1返回0
～	按位取反运算符：对数据的每个二进制位取反，即把0变为1，1变为0	～1返回0～0返回1
〈〈	左移运算符：把"〈〈"左边的运算数的各二进制数位全部左移若干位，"〈〈"右边的数指定移动的位数，高位丢弃，低位补0	1〈〈1返回2
〉〉	右移运算符：把"〉〉"左边的运算数的各二进制数位全部右移若干位，"〉〉"右边的数指定移动的位数，低位丢弃，高位补符号位	8〉〉1返回4

python逻辑运算符：

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与"-如果x为0或False，x and y 返回x的值,否则返回y的值	(8 and 15)返回15
or	x or y	布尔"或"-如果x为非0值或True,x or y返回x的值，否则返回y的值	（8 or 15）返回8
not	not x	布尔"非"-如果x为非0值或True,返回False。如果x为0或False,返回True	not（8 and 15）返回False

python成员运算符：

运算符	描述	实例
in	如果在指定的序列中找到值返回True, 否则返回False	"a"in"abc" 返回True
not in	如果在指定的序列中没有找到值，返回True,否则返回False	1 not in [2,3]返回True

python身份运算符：

运算符	描述	实例
is	判断两个标识符是不是引用同一个对象，如果引用的是同一个对象，则返回True,否则返回False	'a' is 'a' 返回 True
is not	判断两个标识符是不是引用自不同对象，如果引用的不是同一个对象，则返回True,否则返回False	'a' is not 'b' 返回 False

x is y,类似id(x)==id(y),x is not y 类似id(x)!=id(y) 注：id()函数用于获取对象的内存地址
python运算符优先级：

序号	运算符	描述
1	**	指数（最高优先级）
2	～x	按位翻转
3	+x，-x	正负号
4	*，/，//，%	乘法，除法，整除，取余
5	+，-	加法与减法
6	〈〈，〉〉	移位运算符
7	&	按位与
8	^	按位异或
9	\|	按位或
10	<,<=,>,>=,!=,==	比较运算符
11	=，%=，/=，//=，-=，+=，=，*=	赋值运算符
12	is，is not	身份运算符
13	in，not in	成员运算符
14	not x	逻辑运算符“非”
15	and	逻辑运算符“与”
16	or	逻辑运算符“或”

三种不同的数值类型：
整型（int）-通常被称为是整数或者整型，是正或负整数，不带小数点。python3中整型是没有大小限制的。
浮点型（float）-浮点型通常由整数部分与小数部分组成，浮点型也可用科学计数法表示（1.8e2=1.8x10^2=180.0)。
复数（complex）-复数由实数部分和虚数部分组成，可以用a+bj或者complex（a，b）表示，复数的实部和虚部都是浮点型。
python数字类型转换：
有时候，我们需要对数据的类型进行转换，只需要将数据类型作为函数名即可。
比如： int（x）将x转换为一个整数 >>>int(2.7) 2
float(x) 将x转换为一个浮点数 >>>float(9) 9.0
complex(x) 将x转换为一个复数，实数部分为x，虚数部分为0
complex(x，y) 将x和y转换为一个复数，实数部分为x，虚数部分为y >>>complex(3,5) 3+5j

数学函数（import math）：

函数	返回值（描述）
abs(x)	返回数字的绝对值，如abs（-5）返回5
ceil(x)	返回数字的上入整数，如math.ceil(3.2) 返回4
floor(x)	返回数字的下舍整数，如math.floor(5.6) 返回5
log(x)	对数，默认以自然数e为底，如math.log(math.e)返回1.0 math.log(100,10) 返回2 .0
max(x1,x2,...)	返回给定参数的最大值，参数可以为序列
min(x1,x2,...)	返回给定参数的最小值，参数可以为序列
round(x,[,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数
sqrt(x)	返回数字x的平方根，x不能为负数

注；上面的序列可以是字符串，列表，元组，集合。且序列里的元素必须同类型。
例子：
>>>import math
>>>math.ceil(5.2) 6
>>>math.floor(9.8) 9
>>>math.log(16,2) 4.0
>>>max("happy") 'y'找出字符串中ASCII码值最大的字符
>>>min([5,9,3,7,6]) 3
>>>round(3.14159,2) 3.14 #保留两位小数
>>>math.sqrt(81) 9.0
随机数函数：( import random)

函数	返回值（描述）
choice(seq)	从序列的元素中随机挑选一个元素，比如random.choice(range(10)),从0到9中随机挑选一个整数。
randrange([start],stop,[step])	从指定范围内，按指定步长递增的集合中获取一个随机数，start缺省值为0，step缺省值为1.
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子seed，如果你每次调用seed()时都提供相同的种子值，那么将得到相同的随机数序列。
shuffle(lst)	将序列的所有元素随机排序。
uniform(x,y)	随机生成下一个实数，它在[x,y] 范围内，服从平均分布。

这里的序列只能是有序序列，如字符串，列表，元组。
例子：
>>>import random
>>>random.choice(["apple","orange","banana"]) 'orange'
>>>random.choice("xxxxyyyyyyzzzzz") 'y'
>>>random.randrange(0,100,2) #随机生成0～100之间的偶数 48
>>>random.random()*10 #生成0～10之间的随机数 8.192738512619767
>>>list=[1,2,3,4,5]
>>>random.shuffle(list) #打乱列表list
>>>list [3,2,4,1,5]
>>>random.uniform(5,20) #生成5～20之间的随机数 12.395766517579691
>>>random.seed(5)
>>>random.random() 0.6229016948897019
>>>random.random() 0.7417869892607294

>>>random.seed(5)
>>>random.random() 0.6229016948897019
>>>random.random() 0.7417869892607294
三角函数： (import math)

函数	返回值（描述）
sin(x)	返回x弧度的正弦值
cos(x)	返回x弧度的余弦值
tan(x)	返回x弧度的正切值
asin(x)	返回x的反正弦弧度值
acos(x)	返回x的反余弦弧度值
atan(x)	返回x的反正切弧度值
hypot(x,y)	返回欧几里德范数 sqrt(xx+yy)
degrees(x)	将弧度转换为角度如math.degrees(math.pi) 返回180.0
radians(x)	将角度转换为弧度如math.radians(180) 返回3.1415926

python字符串运算符：
a="Nice" b="Day"

操作符	描述	实例
+	字符串连接	a+b输出结果:NiceDay
*	重复输出字符串	a*2输出结果:NiceNice
[ ]	通过索引获取字符串中字符	a[2]的输出结果是c
[:]	截取字符串中的一部分	a[1:3]输出ic
in	成员运算符-如果字符中包含给定的字符返回True	'c' in a 输出结果1
not in	成员运算符-如果字符中不包含给定的字符返回True	'j' not in a输出结果1
r/R	原始字符串-所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符	print(r'\n')原样打印\n而不是输出一个换行

python字符串格式化:
python使用一个字符串作为模板，模板中有格式符，这些格式符为真实值预留位置，并说明真实数值应该呈现的格式。python用一个tuple将多个值传递给模板，每个值对应一个格式符。
["I'm %s. I'm %d years old."]% ("Amy",20) [ ] 字符串模板
模板格式符传递值的元组
python 字符串格式化符号:

符号	描述	实例
%c	格式化字符或者ASCII码	"%c" %65 输出结果A
%s	格式化字符串	"%s" %"hello" 输出结果hello
%d	格式化整数	"%d" %8.5 输出结果8
%o	格式化无符号八进制数	"%o"%16输出结果20
%x%X	格式化无符号十六进制数	"%x"%15输出结果f "%X"%15输出结果F
%f	格式化浮点数字，可指定小数点后的精度	"%.2f"%3.1415输出结果3.14
%e%E	用科学计数法格式化浮点数	"%e"%150输出结果1.500000e+02"%E"%150输出结果1.500000E+02

python字符串函数-1:

函数	返回值（描述）
isalnum( )	如果字符串中至少有一个字符并且所有字符都是字母或数字则返回True,否则返回False
isalpha( )	如果字符串中至少有一个字符并且所有字符都是字母则返回True,否则返回False
isdigit( )	如果字符串中只包含数字则返回True,否则返回False
lower( )	转换字符串中所有大写字符为小写
upper( )	转换字符串中所有小写字符为大写
max(str)	返回字符串中str中最大的字母
min(str)	返回字符串中str中最小的字母

python字符串函数-2:

函数	返回值（描述）
count(str,beg=0,end=len(string))	返回str在字符串中出现的次数，如果beg或者end指定范围则返回指定范围内str出现的次数
find(str,beg=0,end=len(string))	检测str是否包含在字符串中，如果beg和end指定范围，则检查是否包含在指定范围内，如果是返回开始的缩索引值，否则返回-1
join(seq)	以指定字符串作为分隔符，将seq中所有的元素（必须为字符串类型）合并为一个新的字符串
len(string)	返回字符串长度
replace(str1,str2[,max])	将把字符串中的str1替换成str2，如果max指定，则替换不超过max次
split(str="",num=string.count(str))	以 str为分隔符截取字符串，如果num有指定值，则仅截取num个子字符串
strip([chars])	删除字符串首尾的空格，如果chars有指定值（必须为字符串类型），则删除字符串首尾的chars

实例：
>>>str1="fairyland" >>>str1.find('an') 6
>>>len(str1) 9 >>>str2=" ".join(["hello","python"])
>>>str1.isalpha() True >>>str2 "hello python"
>>>max(str1) 'y' >>>str2.replace("hello","love") "love python"
>>>str1.upper() "FAIRYLAND" >>>str2.split(" ") ['hello','python']
>>>str1.count('a') 2 >>>str3=" it's a nice day "
>>>str1.count('a',0,5) 1 >>>str3.strip() "it's a nice day"
python列表运算符：
a=[1,2,3,4] b=['x','y']

操作符	描述	实例
+	列表连接	a+b输出结果[1,2,3,4,'x','y']
*	重复输出列表	b*2输出结果['x','y','x','y']
[ ]	通过索引获取列表中字符	a[1]输出结果2
[:]	截取列表中的一部分	a[1:3]输出结果[2,3]
in	成员运算符-如果列表中包含给定的元素返回True	3 in a输出结果1
not in	成员运算符-如果列表中不包含给定的元素返回True	5 not in a 输出结果1

python列表的函数：

函数	返回值（描述）	实例
len(list)	列表元素的个数	len([1,2,3])输出结果3
max(list)	返回列表元素最大值	max([1,2,3])输出结果3
min(list)	返回列表元素最小值	min([1,2,3])输出结果1
list(seq)	将元组转化为列表	list((1,2,3))输出结果[1,2,3]

python列表的方法-1 :

函数	返回值（描述）
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index ,obj)	将对象插入列表中指定index的位置
list.pop(obj=list[-1])	移除列表中得一个元素（默认最后一个元素）并且返回该元素的值

python列表的方法-2：

函数	返回值（描述）
list.remove(obj )	移除列表中的某个值的第一个匹配项
list.reverse()	反向列表中元素
list.sort([func])	对原列表进行排序
list.clear()	清空列表
list.copy()	复制列表

实例：
>>>list=[1,2,3] >>>list.index(3) 2
>>>list.append(2) >>>list.insert(2,1)
>>>list [1,2,3,2] >>>list [1,2,1,3,2,4,5]
>>>list.count(2) 2 >>>list.pop() 5
>>>list.extend([4,5]) >>>list [1,2,1,3,2,4]
>>>list [1,2,3,2,4,5]
---------------------------------------------------------------------------------------------
>>>list.remove(1) >>>list_=list.copy()
>>>list [2,1,3,2,4] >>>list_ [1,2,2,3,4]
>>>list.reverse() >>>list.clear()
>>>list [4,2,3,1,2] >>>list [ ]
>>>list.sort() >>>list_ [1,2,2,3,4]
>>>list [1,2,2,3,4]
python3 元组
python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。如tup1=('Fairy','python',100),tup2=('a','b','c','d','e')。创建空元组 tup1=(),当元组中只包含一个元素时，需要在后面添加逗号tup1=(123,)。
python元组运算符：
a=(1,2,3,4) b=('hi',)

操作符	描述	实例
+	元组连接	a+b输出(1,2,3,4,'hi')
*	重复输出元组	b*2输出('hi','hi')
[ ]	通过索引获取元组中元素	a[-1]输出4
[:]	截取元组中的一部分	a[:3]输出(1,2,3)
in	成员运算符-如果元组中包含给定的元素返回True	'hi' in b输出True
not in	成员运算符-如果元组中不包含给定的元素返回True	5 not in a输出True

python元组的函数：

函数	返回值（描述）	实例
len(tuple)	元组元素个数	len((1,2,3))输出3
max(tuple)	返回元组元素最大值	max((1,2,3))输出3
min(tuple)	返回元组元素最小值	min((1,2,3))输出1
tuple(seq)	将列表转化为元组	tuple([1,2,3])输出(1,2,3)

修改元组：
元组中的元素值是不允许修改的，但我们可以对元组整体重新赋值，例如：
tup1=(1,2,3) tup2=('x','y')
#以下方法修改元组元素操作是非法的 #tup2[0]='z'
#可以对元素整体重新赋值 tup2=tup1 print(tup2) (1,2,3)

python3 字典：
字典是一种可变容器模型，可存储任意类型对象，字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典在花括号({ }),键必须是唯一的，但值则不必。值可以取任意数据类型，但键必须是不可变的，如字符串，数字或元组。例如client_info={'name':'Amy','age':20,'tag':'cute'}。radian_to_degree={3.14:180,1.57:90}。
字典的增，删，改，查：
>>>staff_info={'name':'Bob','age':20,'tag':'cute'}
>>>staff_info['name'] #访问字典'name'的值 'Bob'
>>>staff_info['name']='Bob Acri' #修改字典中键'name'对应的值
>>>staff_info['title']='SeniorEngineer' #增加一个新键'title'并赋值
>>>del staff_info['age'] #删除字典中的键'age'及对应的值
>>>staff_info.clear() #清空字典中所有元素
>>>del staff_info #删除字典
字典内置函数：
client_info={'name':'Amy','age':20,'tag':'cute'}

函数	返回值（描述）	实例
len(dict)	字典元素个数，即键的总数	len(client_info):3
str(dict)	输出字典，以可打印的字符串表示	str(client_info):"{'name':'Amy','age':20,'tag':'cute'}"
type(variable)	返回输入	type(client_info):<class 'dict'>

字典内置方法-1:

函数	返回值（描述）
dict.clear()	删除字典内所有元素
dict.copy()	返回一个字典的复制
dict.fromkeys(seq[,value])	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
dict.get(key,default=None)	返回指定键的值，如果值不存在字典中返回default值
key in dict	如果键在字典dict里返回true，否则返回false
dict.items()	以列表返回可遍历的(键，值)元组数组

字典内置方法-2:

函数	返回值（描述）
dict.keys()	以列表返回一个字典所有的键
dict.values()	以列表返回字典中的所有值
dict.setdefault(key,default=None)	如果键不存在于字典中，将会添加键并将值设定为default，如果键存在于字典中则值不变
dict.update(dict2)	把字典dict2的键值对更新到dict里
dict.pop(key[,default])	删除字典给定键key所对应的值，返回值为被删除的值，key值必须给出，否则返回default值
dict.popitem()	随机返回并删除字典中的一对键和值

实例-1:
>>>student={'name':'Alice','age':18,'hobby':['reading','travelling']}
>>>student1=student #浅拷贝，引用对象
>>>student2=student.copy() #深拷贝对象(一级目录)，子对象（二级目录）不拷贝，还是引用
>>>student['age']=19
>>>student['hobby'].remove('travelling')
>>>student {'name':'Alice','age':19,'hobby':['reading']}
>>>student1   {'name':'Alice','age':19,'hobby':['reading']}
>>>student2   {'name':'Alice','age':18,'hobby':['reading']}
实例-2:

>>>dict1=dict.fromkeys(range(5))
>>>dict1 {0:None,1:None,2:None,3:None,4:None}
>>>dict1.update({0:'a',1:'b'})
>>>dict1 {0:'a',1:'b',2:None,3:None,4:None}
>>>dict1.items() dict_items([(0,'a'),(1,'b'),(2,None),(3,None),(4,None)])
>>>dict1.keys() dict_keys([0,1,2,3,4])
>>>dict1.values() dict_values(['a','b',None,None,None])
>>>dict1.setdefault(5,'f')
>>>dict1   {0:'a',1:'b',2:None,3:None,4:None,5:'f'}
>>>dict1.get(6,'g') 'g'
>>>dict1.pop(5) 'f'
>>>dict1   {0:'a',1:'b',2:None,3:None,4:None}
>>>dict1.popitem() (4,None)
>>>dict1     {0:'a',1:'b',2:None,3:None}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签： python 网络爬虫

相关文章推荐

新的分享

章节导航