【python与数据分析】CH2 数据类型、运算符与内置函数介绍
·
目录
前言
- 理解变量类型的动态性
- 掌握运算符的用法
- 掌握内置函数的用法
- 理解函数式编程
一、数据类型
1.python常用内置对象
（1）python程序可以分解为模块、语句、表达式以及对象
- 程序由模块构成
- 模块包含语句
- 语句包含表达式
- 表达式建立并处理对象
（2）python是一门面向对象的编程语言，程序中的每一样东西都可以视为一个对象
（3） 对象是python语言中最基本的概念，在python中处理的一切都是对象
- 主要的内置对象有：数字（整型int、浮点型float（实数）、复数）；字符串（不可变性）；列表；字典；元组（不可变性）；文件；集合（不重复性）；
| 对象类型 | 类型名称 | 示例 | 简要说明 |
| 数字 |
int float complex |
1234 3.14,1.3e5 3+4j |
数字大小没有限制，内置支持复数及其运算 |
| 字符串 | str |
'swfu',"I'm student","Python", r'abc',R'bcd' |
使用单引号、双引号、三引号作为界定符，以字母r或R引导的表示原始字符串 |
| 字节串 | bytes | b'hello world' | 以字母b引导，可以使用单引号、双引号、三引号作为界定符 |
| 列表 | list |
[1,2,3] ['a','b',['c',2]] |
所有元素放在一对方括号中，元素之间使用逗号分隔，其中的元素可以是任意类型 |
| 字典 | dict | {1:'food',2:'taste',3:'import'} | 所有元素放在一对大括号中，元素之间使用逗号分隔，元素形式为“键：值” |
| 元组 | tuple |
(2,-5,6) (3,) |
不可变，所有元素放在一对圆括号中，元素之间使用逗号分离，如果元组中只有一个元素的话，后面的逗号不能省略 |
| 集合 |
set frozenset |
{'a','b','c'} | 所有元素放在一对大括号中，元素之间使用逗号分隔，元素不允许重复；另外，set是可变的，而frozenset是不可变的 |
| 布尔型 | bool | True,False | 逻辑值，关系运算符，成员测试运算符，同一性测试运算符组成的表达式的值一般为True或False |
| 空类型 | NoneType | None | 空值 |
| 异常 |
Exception ValueError TypeError |
python内置大量异常类，分别对应不同类型的异常 | |
| 文件 | f=open('data.dat','rb') | open是python内置函数，使用指定的模式打开文件，返回文件对象 | |
| 其他可迭代对象 | 生成器对象、range对象、zip对象、enumerate对象、map对象、filter对象等 | 具有惰性求值的特点，除range对象之外，其他对象中的元素只能看一次 | |
| 编程单元 |
函数（使用def定义） 类（使用class定义） 模块（类型为module） |
类和对象都属于可调用对象，模块用来集中存放函数、类、常量或其他对象 |
- zip,map,enumerate,filter等函数返回的也是对象
- 函数与类也是对象
- python中的对象分为内置对象、标准库对象、扩展库对象
- 内置对象可直接使用，非内置对象需要导入模块才能使用。例如，正弦函数sin(x)——需要导入math模块
2.常量与变量
（1）定义变量名
- 变量名以字母或下划线开头，但以下划线开头的变量在python中有特殊含义
- 变量名中不能有空格以及标点符号
- 不能使用关键字作为变量名（可用print(keyword.kwlist)查看所有python关键字）
- 变量名对英文字母的大小写敏感
（2）注意事项
- 在python中，不需要事先声明变量名及其类型，直接赋值即可创建各种类型的对象变量。这一点适用于python任意类型的对象。
- 赋值语句的执行过程是：首先把等号右侧表达式的值计算出来，然后在内存中寻找一个位置把值存放进去，最后创建变量并指向这个内存地址（python中的变量并不直接存储值，而是存储值的内存地址或者引用，这是变量类型随时可以改变的原因）。
- python属于强类型编程语言，python解释器会根据赋值或运算来自动推断变量类型；python还是动态类型语言，变量的类型也是可以随时变化的。
- 例
>>>x=3 #创建了整型变量x，并赋值为3
>>>x='hello world' #创建了字符串变量，并赋值为'hello world'
>>>print(type(x))
<class 'str'>
3.数字
（1）在ptyhon中，内置的函数类型有整数、实数和复数
（2）整数类型除了常见的十进制整数，还有：
- 二进制：以0b开头，每一位只能是0或1
- 八进制：以0o开头，每一位只能是0、1、2、3、4、5、6、7这八位数字
- 十六进制：以0x开头，每一位只能是0、1、2、3、4、5、6、7、8、9、a、b、c、d、e、f之一
（3）python支持任意大的数字，具体可以大到什么程度仅受内存大小的限制
（4）由于精度问题，对于实数运算可能会有一定的误差，应尽量避免在实数之间直接进行相等性测试，而是应该以二者之差的绝对值是否足够小作为两个实数是否相等的依据
（5）在数字的算术运算表达式求值时会进行隐式的类型转换，如果存在复数则都变成负数，如果没有复数但有实数就都变成实数，如果都是整数则不进行类型变换
（6）python内置支持复数类型及其运算，并且形式上与数学上的复数完全一致
（7）python3.6.x及以上版本支持在数字中间位置使用单个下划线作为分割来提高数字的可读性，类似于数学上使用逗号作为千位分隔符（单个下划线可以出现在中间任意位置，但不能出现在开头和结尾，也不能使用多个连续的下划线）。
>>> 9999**99 #这里**是幂乘运算符，等价于内置函数pow()
990148353526723487602263124753282625570559528895791057324326529121794837894053513464422176826916433932586924386677766244032001623756821400432975051208820204980098735552703841362304669970510691243800218202840374329378800694920309791954185117798434329591212159106298699938669908067573374724331208942425544893910910073205049031656789220889560732962926226305865706593594917896276756396848514900989999
>>> 0.3+0.2 #实数相加
0.5
>>> 0.4-0.1 #实数相减，结果稍微有点偏差
0.30000000000000004
>>> 0.4-0.1==0.3 #应尽量避免直接比较两个实数是否相等
False
>>> abs(0.4-0.1-0.3)<1e-6 #这里1e-6表示10的-6次方
True
>>> x=3+4j #使用j或J表示复数虚部
>>> y=5+6j
>>> x+y
(8+10j)
>>> x*y
(-9+38j)
>>> abs(x) #内置函数abs()可用来计算复数的模
5.0
>>> x.imag
4.0
>>> x.real
3.0
>>> x.conjugate() #共轭复数
(3-4j)
4.字符串
（1）在python中，没有字符常量和变量的概念，只有字符串类型的常量和变量，单个字符也是字符串。使用单引号、双引号、三单引号、三双引号作为定界符(delimiter)表示字符串，并且不同定界符之间可以互相嵌套。
（2）python 3.x全面支持中文，中文和英文字母都可以作为一个字符对待，甚至可以使用中文作为变量名。
（3）除了支持使用加号运算符连接字符串外，python字符串还提供了大量的方法支持格式化、查找、替换、排版等操作。
>>> x='Hello world' #使用单引号作为界定符
>>> x="ptyhon is a great language" #使用双引号作为界定符
>>> x='''Tom said,"Let's go"''' #不同界定符之间可以互相嵌套
>>> print(x)
Tom said,"Let's go"
>>> x='good '+'morning' #连接字符串
>>> x
'good morning'
>>> x='good ''morning' #连接字符串，仅适用于字符串常量
>>> x
'good morning'
>>> x='good'
>>> x=x'morning' #不适用于字符串变量
SyntaxError: invalid syntax
>>> x=x+'morning' #字符串变量之间的连接可以使用加号
>>> x
'goodmorning'
5.列表、元组、字典、集合
（1）表格介绍
| 列表 | 元组 | 字典 | 集合 | |
| 类型名称 | list | tuple | dict | set |
| 定界符 | 方括号[] | 圆括号() | 大括号{} | 大括号{} |
| 是否可变 | 是 | 否 | 是 | 是 |
| 是否有序 | 是 | 是 | 否 | 否 |
| 是否支持下标 | 是（使用序号作为下标） | 是（使用序号作为下标） | 是（使用“键”作为下标） | 否 |
| 元素分隔符 | 逗号 | 逗号 | 逗号 | 逗号 |
| 对元素形式的要求 | 无 | 无 | 键：值 | 必须可哈希 |
| 对元素值的要求 | 无 | 无 | “键”必须可哈希 | 必须可哈希 |
| 元素是否可重复 | 是 | 是 | “键”不允许重复，“值”可以重复 | 否 |
| 元素查找速度 | 非常慢 | 很慢 | 非常快 | 非常快 |
| 新增和删除元素速度 | 尾部操作快，其他位置慢 | 不允许 | 快 | 快 |
（2）例
>>> x_list=[1,2,3] #创建列表对象
>>> x_tuple=(1,2,3) #创建元组对象
>>> x_dict={'a':97,'b':98,'c':99} #创建字典对象
>>> x_set={1,2,3} #创建集合对象
>>> print(x_list[1]) #使用下标访问指定位置的元素
2
>>> print(x_tuple[1]) #元组也支持使用序号作为下标
2
>>> print(x_dict['a']) #字典对象的下标是“键”
97
>>> 3 in x_set #成员测试
True
二、python运算符与表达式
1.相关定义
- 运算符：用于执行程序代码运算，会针对一个以上操作数项目来进行计算。eg，2+3，操作数是2和3，运算符是“+”。
- 表达式：由数字、运算符、数字分组符号（括号）、自由变量和约束变量等以能求得数值的有意义排列方式所得的集合。（在python中，单个常量或变量可以看作最简单的表达式，使用除赋值运算符之外的其他任意运算符和函数调用连接的式子也属于表达式）。
2.常见运算符列表
| 算数运算符 | ||
| 运算符 | 描述 | |
| + | 加-两个对象相加 | |
| - | 减-得到负数或是一个数减去另一个数 | |
| * | 乘-两个数相乘或是返回一个被重复若干次的字符串 | |
| / | 除-x除以y | |
| % | 取模-返回除法的余数 | |
| ** | 幂-返回x的y次幂 | |
| // | 取整除-返回商的整数部分（向下取整） | |
| 比较运算符 | |
| 运算符 | 描述 |
| == | 等于-比较对象是否相等 |
| != | 不等于-比较两个对象是否不相等 |
| <> | 不等于-比较两个对象是否不相等 |
| > | 大于-返回x是否大于y |
| < | 小于-返回x是否小于y。所有比较云孙福返回1表示真，返回0表示假。这分别与特殊的变量True和False等价 |
| >= | 大于等于-返回x是否大于等于y |
| <= | 小于等于-返回x是否小于等于y |
| 赋值运算符 | |
| 运算符 | 描述 |
| = | 简单的赋值运算符 |
| += | 加法赋值运算符 |
| -= | 减法赋值运算符 |
| *= | 乘法赋值运算符 |
| /= | 除法赋值运算符 |
| %= | 取模赋值运算符 |
| **= | 幂赋值运算符 |
| //= | 取整除赋值运算符 |
| 逻辑运算符 | ||
| 运算符 | 逻辑表达式 | 描述 |
| and | x and y | 布尔“与”-如果x为False，x and y返回False，否则它返回y的计算值 |
| or | x or y | 布尔“或”-如果x是非0，它返回x的值，否则它返回y的计算值 |
| not | not x | 布尔“非”-如果x为True，返回False，它返回True |
| 位运算符 | |
| 运算符 | 描述 |
| & | 按位与运算符：参与运算的两个值，如果两个相应位都是1，则该位的结果为1，否则为0 |
| | | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 |
| ~ | 按位取反运算符：对数据的每个二进制位取反，即把1变为0，把0变为1。~x类似于-x-1 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由<<右边的数字指定了移动的位数，高位丢弃，低位补0 |
| >> | 右移动运算符：把“<<”左边的运算数的各二进位全部右移若干位，>>右边的数字指定了移动的位数 |
| 成员运算符 | |
| 运算符 | 描述 |
| in | 如果在指定的序列中找到值返回True，否则返回False |
| not in | 如果在指定的序列中没有找到值返回True，否则返回False |
| 身份运算符 | |
| 运算符 | 描述 |
| is | is是判断两个标识符是不是引用自一个对象 |
| is not | is not是判断两个标识符是不是引用自不同对象 |
3.运算符优先级
- 算数运算符-位运算符-成员测试运算符-关系运算符-逻辑运算符
- 算术运算符：先乘除，后加减
- 虽然python运算符有一套严格的优先级规则，但是强烈建议在编写复杂表达式时使用圆括号来说明其中的逻辑来提高代码的可读性
4.算数运算符
- +运算符除了用于算术加法以外，还可以用于列表、元组、字符串的连接，但不支持不同类型的对象之间的相加或连接
>>> [1,2,3]+[4,5,6] #连接两个列表
[1, 2, 3, 4, 5, 6]
>>> (1,2,3)+(4,) #连接两个元组
(1, 2, 3, 4)
>>> 'abcd'+'1234' #连接两个字符串
'abcd1234'
>>> 'A'+1 #不支持字符与数字相加，抛出异常
Traceback (most recent call last):
File "<pyshell#4>", line 1, in <module>
'A'+1
TypeError: can only concatenate str (not "int") to str
>>> True+3 #python内部把True当作1处理
4
>>> False+3 #python内部把False当作0处理
3
- *运算符除了表示算数乘法，还可以用于列表、元组、字符串这几个序列类型与整数的乘法，表示序列元素的重复，生成新的序列对象。字典和集合不支持与整数的相乘，因为其中的元素是不允许重复的
>>> True*3
3
>>> False*3
0
>>> [1,2,3]*3 #将列表[1,2,3]中的元素重复三次并接在一起得新列表
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> (1,2,3)*3 #将元组(1,2,3)中的元素重复三次并接在一起得新元组
(1, 2, 3, 1, 2, 3, 1, 2, 3)
>>> 'abc'*3 #将字符串'abc'中的元素重复三次并接在一起得新字符串
'abcabcabc'
- 运算符/和//在python中分别表示算数除法和算数求整商（floor division）
>>> 3/2 #数学意义上的除法
1.5
>>> 15//4 #如果两个操作数都是整数，结果为整数，向下取整
3
>>> 15.0//4 #如果两个操作数中有实数，结果为实数形式的整数值（浮点数）
3.0
>>> -15//4 #向下取整
-4
>>> 3/2,3.0/2,15/4,15.0/4,-15/4,15//4,-15//4
(1.5, 1.5, 3.75, 3.75, -3.75, 3, -4)
- %运算符可以用于整数或实数的求余数运算，还可以用于字符串格式化，但是这种用法并不推荐
>>> 789%23 #余数（即789=34*23+7）
7
>>> 123.45%3.2 #可以对实数进行余数运算，注意精度问题
1.849999999999996
>>> '%c,%d'%(65,65) #把65分别格式化为字符和整数
'A,65'
>>> '%f,%s'%(65,65) #把65分别格式化为实数和字符串
'65.000000,65'
- **运算符表示幂乘
>>> 3**2 #3的2次方，等价于pow（3，2）
9
>>> pow(3,2,8) #等价于（3**2）%8
1
>>> 9**0.5 #9的0.5次方，平方根
3.0
>>> (-9)**0.5 #可以计算复数的平方根（结果为复数3j，有精度问题）
(1.8369701987210297e-16+3j)
5.关系运算符
- python关系运算符最大的特点是可以连用。使用关系运算符的一个重要前提是操作数之间必须可以比较大小
>>> 1<3<5 #等价于1<3and3<5
True
>>> 1>6<math.sqrt(9) #具有惰性求值或者逻辑短路的特点
False
>>> 1<6<math.sqrt(9) #还没有导入math模块，抛出异常
Traceback (most recent call last):
File "<pyshell#29>", line 1, in <module>
1<6<math.sqrt(9)
NameError: name 'math' is not defined
>>> import math
>>> 1<6<math.sqrt(9)
False
>>> 'Hello'>'world' #比较字符串大小
False
>>> [1,2,3]<[1,2,4] #比较列表大小
True
>>> 'Hello'>3 #字符串和数字不能比较
Traceback (most recent call last):
File "<pyshell#34>", line 1, in <module>
'Hello'>3
TypeError: '>' not supported between instances of 'str' and 'int'
>>> {1,2,3}<{1,2,3,4} #测试是否是子集
True
>>> {1,2,3}=={3,2,1} #测试两个集合是否相等
True
>>> {1,2,4}>{1,2,3} #集合之间的包含测试
False
6.成员测试运算符
- 成员测试运算符in用于成员测试，即测试一个对象是否为另一个对象的元素
>>> 3 in [1,2,3] #测试3是否在于列表[1,2,3]中
True
>>> 5 in range(1,10,1) #range（）是用来生成指定范围数字的内置函数
True
>>> 'abc'in'abcdef' #子字符串测试
True
>>> for i in(3,5,7): #循环，成员遍历
... print(i,end='\t')
...
...
3 5 7 7.集合运算符
- 集合的交集、并集、对称差集等运算借助于&、|、^来实现，而差集则使用减号运算符实现
>>> {1,2,3}|{3,4,5} #并集，自动去除重复元素
{1, 2, 3, 4, 5}
>>> {1,2,3}&{3,4,5} #交集
{3}
>>> {1,2,3}^{3,4,5} #对称差集
{1, 2, 4, 5}
>>> {1,2,3}-{3,4,5} #差集
{1, 2}8.逻辑运算符
- 逻辑运算符and、or、not常用来连接条件表达式构成更加复杂的条件表达式，并且and和or具有惰性求值或逻辑短路的特点，当连接多个表达式时只计算必须计算的值
- 运算符and和or并不一定会返回True或False，而是得到最后一个被计算的表达式的值，但是运算符not一定会返回True或False
>>> 3>5 and a>3 #主义，此时并没有定义变量a（惰性求值！）
False
>>> 3>5 or a>3 #3>5的值为False，所以需要计算后面的表达式
Traceback (most recent call last):
File "<pyshell#50>", line 1, in <module>
3>5 or a>3
NameError: name 'a' is not defined
>>> 3 and 5>2
True
>>> 3 and 5 #最后一个计算的表达式的值作为整个表达式的值
5
>>> 3 not in [1,2,3] #逻辑非运算not
False
>>> 3 is not 5 #not的计算结果只能是True或False之一
True
>>> not 3
False
>>> not 0
True9.补充说明
- python中的位运算符：|、^、&、<<、>>、~等
>>> x=0b110
>>> x
6
>>> y=0b11
>>> y
3
>>> x|y
7
>>> x^y
5
>>> x&y
2
>>> x<<2
24
>>> x>>2
1
>>> ~x
-7
>>> ~x==-(x+1)
True- python不支持++和--运算符，虽然在形式上有时候似乎可以这样用，但实际上另有含义
>>> i=3
>>> ++i #正正得正
3
>>> +(+3) #与++i等价
3
>>> i++ #python不支持++运算符，语法错误
SyntaxError: invalid syntax
>>> --i #负负得正，等价于-（-i）
3
>>> ---i #等价于-（-（-i））
-3
>>> i-- #python不支持--运算符，语法错误
SyntaxError: invalid syntax三、python常用内置函数用法精要
1.定义
- 内置函数（BIF，built-in functions）：python内置对象类型之一，不需要额外导入任何模块即可使用，这些内置对象都封装在内置模块_builtins_之中，用C语言实现并且进行了大量优化，具有非常快的运行速度，推荐优先使用。使用内置函数dir()可以查看所有内置函数和内置对象。（>>>dir(_builtins_)）
- 使用help(函数名)可以查看某个函数的用法
| 函数 | 功能简要说明 |
| abs(x) |
返回数字x的绝对值或复数x的模 |
| all(iterable) |
如果对于可迭代对象中所有元素x都等价于True，也就是对于所有元素x都有bool(x)等于True，则返回True。对于空的可迭代对象也返回True |
| any(iterable) |
只要可迭代对象iterable中存在元素x使得bool(x)为True，则返回True。对于空的可迭代对象，返回False |
| ascii(obj) |
把对象转换为ASCII码表示形式，必要的时候使用转义字符来表示特定的字符 |
| bin(x) |
把整数x转换为二进制串表示形式 |
| bool(x) |
返回与x等价的布尔值True或False |
| bytes(x) |
生成字节串，或把指定对象x转换为字节串表示形式 |
| callable(obj) |
测试对象obj是否可调用。类和函数是可调用的，包含__call__()方法的类的对象也是可调用的 |
| compile() |
用于把Python代码编译成可被exec()或eval()函数执行的代码对象 |
| complex(real,[imag]) |
返回复数 |
| chr(x) |
返回Unicode编码为x的字符 |
| delattr(obj,name) |
删除属性，等价于del obj.name |
| dir(obj) |
返回指定对象或模块obj的成员列表，如果不带参数则返回当前作用域内所有标识符 |
| divmod(x,y) |
返回包含整商和余数的元组((x-x%y)/y, x%y) |
| enumerate(iterable,[start]) |
返回包含元素形式为(0, iterable[0]), (1, iterable[1]), (2, iterable[2]), ...的迭代器对象 |
| eval(s[,globals,[locals]]) |
计算并返回字符串s中表达式的值 |
| exec(x) |
执行代码或代码对象x |
| exit() |
退出当前解释器环境 |
| filter(func,seq) |
返回filter对象，其中包含序列seq中使得单参数函数func返回值为True的那些元素，如果函数func为None则返回包含seq中等价于True的元素的filter对象 |
| float(x) |
把整数或字符串x转换为浮点数并返回 |
| frozenset([x]) |
创建不可变的集合对象 |
| getattr(obj,name,[default]) |
获取对象中指定属性的值，等价于obj.name，如果不存在指定属性则返回default的值，如果要访问的属性不存在并且没有指定default则抛出异常 |
| globals() |
返回包含当前作用域内全局变量及其值的字典 |
| hasattr(obj,name) |
测试对象obj是否具有名为name的成员 |
| hash(x) |
返回对象x的哈希值，如果x不可哈希则抛出异常 |
| help(obj) |
返回对象obj的帮助信息 |
| hex(x) |
把整数x转换为十六进制串 |
| id(obj) |
返回对象obj的标识（内存地址） |
| input([提示]) |
显示提示，接收键盘输入的内容，返回字符串 |
| int(x[,d]) |
返回实数（float）、分数（Fraction）或高精度实数（Decimal）x的整数部分，或把d进制的字符串x转换为十进制并返回，d默认为十进制 |
| isinstance(obj,class-or-type-or-tuple) |
测试对象obj是否属于指定类型（如果有多个类型的话需要放到元组中）的实例 |
| iter(…) |
返回指定对象的可迭代对象 |
| len(obj) |
返回对象obj包含的元素个数，适用于列表、元组、集合、字典、字符串以及range对象和其他可迭代对象 |
| list([x])、set([x])、tuple([x])、dict([x]) | 把对象x转换为列表、集合、元组或字典并返回，或生成空列表、空集合、空元组、空字典 |
| locals() | 返回包含当前作用域内局部变量及其值的字典 |
| map(func,*iterables) | 返回包含若干函数值得map对象，函数func的参数分别来自于itrables指定的每个迭代对象 |
| max(x)、min(x) | 返回可迭代对象x中的最大值、最小值，要求x中的所有元素之间可比较大小，允许指定排序规则和x为空时返回的默认值 |
| next(iterator,[default]) | 返回可迭代对象x中的下一个元素，允许指定迭代结束后继续迭代时返回的默认值 |
| oct(x) | 把整数x转换为八进制串 |
| open(name,[mode]) | 以指定模式mode打开文件name并返回文件对象 |
| ord(x) | 返回1个字符x的Unicode编码 |
| pow(x,y,z=None) |
返回x的y次方，等价于x ** y或(x ** y) % z |
|
print(value,…,sep='',end='\n', file=sys.stdout,flush=False) |
基本输出函数 |
| quit() | 退出当前解释器环境 |
| range([start],end,[step]) | 返回range对象，其中包含左闭右开区间[start,end)内以step为步长的整数 |
| reduce(func,sequence,[initial]) | 将双参数的函数func以迭代的方式从左到右依次应用至序列seq中每个元素，最终返回单个值作为结果。在ptyhon 2.x中该函数为内置函数，在python 3.x中需要从functools中导入reduce函数再使用 |
| repr(obj) | 返回对象obj的规范化字符串表示形式，对于大多数对象有eval(repr(obj))==obj |
|
reversed(seq) |
返回seq（可以是列表、元组、字符串、range以及其他可迭代对象）中所有元素逆序后的迭代器对象 |
| round(x,[小数位数]) | 对x进行四舍五入，若不指定小数位数，则返回整数 |
|
sorted(iterable,key=None, reverse=False) |
返回排序后的列表，其中iterable表示要排序的序列或迭代对象，key用来指定排序规则或依据，reverse用来指定升序或降序。该函数不改变iterable内任何元素的顺序 |
| str(obj) | 把对象obj直接转换为字符串 |
| sum(x,start=0) | 返回序列x中所有元素之和，返回start+sum(x) |
| type(obj) | 返回对象obj的类型 |
| zip(seq1,[seq2[…]]) | 返回zip对象，其中元素为(seq1[i],seq2[i],…)形式的元组，最终结果中包含的元素个数取决于所有参数序列或可迭代对象中最短的那个 |
2.类型转换与类型判断
- 内置函数bin()、oct()、hex()用来将整数转换为二进制、八进制和十六进制，这三个函数都要求参数必须为整数
>>> bin(555) #把数字转换为二进制串
'0b1000101011'
>>> oct(555) #转换为八进制串
'0o1053'
>>> hex(555) #转换为十六进制串
'0x22b'- 内置函数float()用来将其他类型数据转换为实数，complex()可以用来生成复数
>>> float(3) #把整数转换为实数
3.0
>>> float('3') #把数字字符串转换为实数
3.0
>>> float('inf') #无穷大，inf不区分大小写
inf
>>> complex(3) #指定实部
(3+0j)
>>> complex('inf')
(inf+0j)- ord()和chr()是一对功能相反的函数，ord()用来返回单个字符的Unicode码，而chr()则用来返回Unicode编码对应的字符，str()则直接将其任意类型参数转换为字符串
>>> ord('a') #查看指定字符的Unicode编码
97
>>> chr(65) #返回数字65对应的字符
'A'
>>> chr(ord('A')+1) #python不允许字符串和数字之间的加法操作
'B'
>>> chr(ord('国')+1) #支持中文
'图'
>>> ord('韩') #这个用法仅适用于python 3.x
38889
>>> str(1234) #直接变成字符串
'1234'
>>> str([1,2,3,4])
'[1, 2, 3, 4]'
>>> str((1,2,3,4))
'(1, 2, 3, 4)'
>>> str({1,2,3})
'{1, 2, 3}'
>>> x=str([1,2,3])
>>> x
'[1, 2, 3]'
>>> list(x) #注意x[0]='['
['[', '1', ',', ' ', '2', ',', ' ', '3', ']']- list()、tuple()、dict()、set()用来把其他类型的数据转换为列表、元组、字典、集合；或者创建空列表、空元组、空字典、空集合
>>> list(range(5)) #把range对象转换为列表
[0, 1, 2, 3, 4]
>>> tuple(_) #一个下划线表示上一次正确的输出结果
(0, 1, 2, 3, 4)
>>> dict(zip('1234','abcde')) #创建字典
{'1': 'a', '2': 'b', '3': 'c', '4': 'd'}
>>> set('1112234') #创建可变集合，自动去除重复
{'1', '2', '3', '4'}
- 内置函数type()和isinstance()可以用来判断数据类型，常用来对函数参数进行检查，可以避免错误的参数类型导致函数崩溃或返回意料之外的结果
>>> type(3) #查看3的类型
<class 'int'>
>>> type([3]) #查看[3]的类型
<class 'list'>
>>> type({3}) in (list,tuple,dict,set) #判断{3}是否为list,tuple，dict或set类型
True
>>> isinstance(3,int) #判断3是否为int类型
True
>>> isinstance(3j,(int,float,complex))
True- 内置函数eval(）用来计算字符串的值，在有些场合也可以用来实现类型转换的功能
-
>>> eval('3+5') #把数字字符串转换为数字 8 >>> eval('09') #抛出异常，不允许以0开头的数字 Traceback (most recent call last): File "<pyshell#31>", line 1, in <module> eval('09') File "<string>", line 1 09 ^ SyntaxError: leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers >>> int('09') #这样转换是可以的 9 >>> list(str([1,2,3,4])) #字符串中每个字符都变为列表中的元素 ['[', '1', ',', ' ', '2', ',', ' ', '3', ',', ' ', '4', ']'] >>> eval(str([1,2,3,4])) #字符串求值 [1, 2, 3, 4] >>> eval("1,q,3,4,5") #q未知 Traceback (most recent call last): File "<pyshell#35>", line 1, in <module> eval("1,q,3,4,5") File "<string>", line 1, in <module> NameError: name 'q' is not defined
3.最值与求和
-
max()、min()、sum() 这三个内置函数分别用于计算列表、元组或其他包含 有限个 元素的 可迭代对象 中所有元素最大值、最小值以及所有元素之和。
-
sum() 默认（可以通过start参数来改变）支持包含 数值型 元素的 序列或可迭代对象 ，max () 和 min() 则要求序列或可迭代对象中的元素之间可比较大小 。
>>> from random import randint
>>> a=[randint(1,100) for i in range(10)] #包含10个[1,100]之间随机数的列表
>>> a
[31, 38, 83, 65, 46, 36, 50, 71, 44, 17]
>>> print(max(a),min(a),sum(a))
83 17 481
>>> sum(a)/len(a) #平均值
48.1- 函数max()和min()还支持default参数和key参数，其中default参数用来指定可迭代对象为空时默认返回的最大值或最小值，而key参数用来指定比较大小的依据或规则，可以是函数或lambda表达式
>>> max(['2','111']) #不指定排序规则
'2'
>>> max(['2','111'],key=len) #返回最长的字符串
'111'
>>> print(max([],default=None)) #对空列表求最大值，返回空值None
None4.基本输入输出
- input()和print()是python的基本输入输出函数，前者用来接收用户的键盘输入，后者用来把数据以指定的格式输出到标准控制台或指定的文件对象。不论用户输入什么内容，input()一律返回字符串对待，必要的时候可以使用内置函数int()、float()或eval()对用户输入的内容进行类型转换
- 内置函数print()用于输出信息到标准控制台或指定文件，语法格式为：print(value,…,sep='',end='\n',file=sys.stdout,flush=False)。sep参数之前为需要输入的内容，sep参数用于指定数据之间的分隔符，默认为空格，end参数用于指定输出完数据之后再输出什么字符
>>> x=input('please input:')
please input:345
>>> x
'345'
>>> type(x) #把用户的输入作为字符串对待
<class 'str'>
>>> int(x) #转换为整数
345
>>> eval(x) #对字符串求值，或类型转换
345
>>> print(1,2,3,4,sep='\t') #修改默认分隔符
1 2 3 4
>>> for i in range(10): #修改end参数，每个输出后不换行
... print(i,end=' ')
...
...
0 1 2 3 4 5 6 7 8 9
5.排序和逆序
- sorted()对列表、元组、字典、集合或其他可迭代对象进行排序并返回新列表，reversed()对可迭代对象（生成器对象和具有惰性求值特性的zip、map、filter、enumerate等类似对象除外）进行翻转（首尾交换）并返回可迭代的reversed对象
>>> x=list(range(22))
>>> import random
>>> random.shuffle(x) #打乱顺序
>>> x
[21, 8, 0, 14, 5, 12, 7, 6, 19, 18, 13, 16, 9, 1, 17, 3, 20, 11, 10, 4, 15, 2]
>>> sorted(x) #以默认规则排序
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]
>>> sorted(x,key=lambda item:len(str(item)),reverse=True) #按转换成字符串以后的长度降序排列
[21, 14, 12, 19, 18, 13, 16, 17, 20, 11, 10, 15, 8, 0, 5, 7, 6, 9, 1, 3, 4, 2]
>>> sorted(x,key=str) #按转换成字符串以后的大小升序排列
[0, 1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 20, 21, 3, 4, 5, 6, 7, 8, 9]
>>> x=['aaaa','bc','d','b','ba']
>>> sorted(x,key=lambda item:(len(item),item)) #先按长度排序，长度一样的正常排序
['b', 'd', 'ba', 'bc', 'aaaa']
>>> reversed(x) #逆序，返回reversed对象
<list_reverseiterator object at 0x000002C84007E230>
>>> list(reversed(x)) #reversed对象是可迭代的
['ba', 'b', 'd', 'bc', 'aaaa']6.枚举与迭代
- enumerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组
>>> list(enumerate('abcd')) #枚举字符串中的元素
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> list(enumerate(['python','greate'])) #枚举列表中的元素
[(0, 'python'), (1, 'greate')]
>>> list(enumerate({'a':97,'b':98,'c':99})) #枚举字典中的键
[(0, 'a'), (1, 'b'), (2, 'c')]
>>> list(enumerate({'a':97,'b':98,'c':99}.items())) #枚举字典中的元素
[(0, ('a', 97)), (1, ('b', 98)), (2, ('c', 99))]
>>> for index,value in enumerate(range(10,15)): #枚举range对象中的元素
... print((index,value),end=' ')
...
...
(0, 10) (1, 11) (2, 12) (3, 13) (4, 14) 7.map()、reduce()、filter()
- 内置函数map()把一个函数func依次映射到序列或迭代器对象的每个元素上，并返回一个可迭代的map对象作为结果，map对象中每个元素是原序列中元素经过函数func处理后的结果
>>> list(map(str,range(5))) #把列表中元素转换为字符串
['0', '1', '2', '3', '4']
>>> def add5(v): #单参数函数
... return v+5
...
>>> list(map(add5,range(10))) #把单参数函数映射到一个序列的所有元素（每个元素+5）
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> def add(x,y): #可以接收两个参数的函数
... return x+y
...
>>> list(map(add,range(5),range(5,10))) #把双参数函数映射到两个序列上
[5, 7, 9, 11, 13]
>>> import random
>>> x=random.randint(1,1e30) #生成指定范围内的随机整数（1e30中的1必须写）
>>> x
602672024174227714079939455064
>>> list(map(int,str(x))) #T恤大整数每位上的数字
[6, 0, 2, 6, 7, 2, 0, 2, 4, 1, 7, 4, 2, 2, 7, 7, 1, 4, 0, 7, 9, 9, 3, 9, 4, 5, 5, 0, 6, 4]- 标准库functoools中的函数reduce()可以将一个接收2个参数的函数以迭代累积的方式从左到右依次作用到一个序列或迭代器对象的所有元素上，并且允许指定一个初始值
>>> from functools import reduce
>>> seq=list(range(1,10))
>>> reduce(lambda x,y:x+y,seq) #1+2=3 3+3=6 6+4=10……
45- 内置函数filter()将一个单参数函数作用到一个序列上，返回该序列中使得该函数返回值为True的那些元素组成的filter对象，如果指定函数为None，则返回序列中等价于True中的元素
>>> seq=['foo','x41','?!','***']
>>> def func(x):
... return x.isalnum() #测试是否为字母或数字
...
>>> filter(func,seq) #返回filter对象
<filter object at 0x000002C84007FBE0>
>>> list(filter(func,seq)) #把filter对象转换为列表
['foo', 'x41']
>>> "1111".isalnum() #测试是否为字母或数字
True
>>> "d45_".isalnum() #测试是否为字母或数字
False
8.range()
- range()是python开发中非常常用的一个内置函数，语法格式为range([start],end,[step])，有range(end)、range(start,end)和range(start,end,step)三种用法。该函数返回具有惰性求值特点的range对象，其中包含左闭右开区间[start,end)内以step为步长的整数。参数start默认为0，step默认为1
>>> range(5)
range(0, 5)
>>> list(_)
[0, 1, 2, 3, 4]
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]9.zip()
- zip()函数用来把多个可迭代对象中的元素压缩在一起，返回一个可迭代的zip对象，其中每个元素都是包含原来的多个可迭代对象对应位置上元素的元组，如果拉拉链一样。
>>> list(zip('abcd',[1,2,3]))
[('a', 1), ('b', 2), ('c', 3)]
>>> list(zip('123','abc',',.!')) #压缩三个序列
[('1', 'a', ','), ('2', 'b', '.'), ('3', 'c', '!')]四、python关键字简要说明
- python关键字只允许用来表达特定的语义，不允许通过任何其他方式改变它们的含义，也不能用来做变量名、函数名或类名等标识符
- 在python开发环境中导入模块keyword之后，可以使用print(keyword.kwlist)查看所有关键字
| 关键字 | 含义 |
| False | 常量，逻辑假 |
| None | 常量，空值 |
| True | 常量，逻辑真 |
| and | 逻辑与运算 |
| as | 在import或except语句中给对象起别名 |
| assert | 断言，用来确定某个条件必须满足，可用来帮助调试程序 |
| break | 用在循环中，提前结束break所在层次的循环 |
| class | 用来定义类 |
| continue | 用在循环中，提前结束本次循环 |
| def | 用来定义函数 |
| del | 用来删除对象或对象成员 |
| elif | 用在选择结构中，表示else if的意思 |
| else | 可以用在选择结构、循环结构和异常处理结构中 |
| except | 用在异常处理结构中，用来捕获特定类型的异常 |
| finally | 用在异常处理结构中，用来表示不论是否发生异常都会执行的代码 |
| for | 构造for循环，用来迭代序列或可迭代对象中的所有元素 |
| from | 明确指定从哪个模块中导入什么对象，例如from math import sin;还可以与yield一起构成yield表达式 |
| global | 定义或声明全局变量 |
| if | 用在选择结构中 |
| import | 用来导入模块或模块中的对象 |
| in | 成员测试 |
| is | 同一性测试 |
| lambda | 用来定义lambda表达式，类似于函数 |
| nonlocal | 用来声明nonlocal变量 |
| not | 逻辑非运算 |
| or | 逻辑或运算 |
| pass | 空语句，执行该语句时什么也不做，常用作占位符 |
| raise | 用来显示抛出异常 |
| return |
在函数中用来返回值，如果没有指定返回值，表示返回空值None |
| try |
在异常处理结构中用来限定可能会引发异常的代码块 |
| while | 用来构造while循环结构，只要条件表达式等价于True就重复执行限定的代码块 |
| with |
上下文管理，具有自动管理资源的功能 |
| yield |
在生成器函数中用来返回值 |
腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。
更多推荐
0
0- 0
已为社区贡献4条内容
所有评论(0)