Python学习笔记(二)

标识符和关键字

1，邮箱的Python标识符是任意长度的非空字符序列（引导字符+后续字符。）

python标识符必须符合两条规则--标识符区分大小写

（1）只要是unicode编码字母都可以充当引导字符，包括unicode编码中认为是数字的任意字符。

（2）关于(_) 的使用，名的开头和结尾尽量避免使用(_)

for _ in [1,2,3,4,5]

print(" _ 可省略变量")

Intergral类型

2,python提供了两个内置订单Intergral类型：int，bool

在布尔表达式中：0 与 False 表示Flase，其他任意整数都表示True

其他表达式中：True表示1，False表示0

整数

3,整数的大小只受限于机器的内存大小

二进制使用0b开头

八进制使用0o开头

十六进制使用0x开头 （后面字符不区分大小写）

数值操作符

+， -， *， /, //返回整数部分，%取余数，x**y 计算x的y次幂，

abs(x)表示x的绝对值

divmode(x,y)以二元组的形式返回x除以y所得的商和余数

pow(x,y)计算x的y次幂 等同于**

round(x,n)返回x四舍五入后得到的相应整数

使用数据类型创建对象

4,(1)不使用参数调用数据类型函数，会赋值一个默认值

整数位0，str为空字符，

>>> x=int()
>>> x
0
>>> x=str()
>>> x
''
>>> x=list()
>>> x
[]

　(2)使用一个参数调用数据类型函数

如果给定的类型是相同的数据类型，就创建一个新对象，新对象是原始对象的一个浅拷贝。

如果给定参数支持到给定数据类型的转换，但转换失败，会产生一个TypeError异常

如果给定的参数不是相同的数据类型，会尝试进行数据转换

bin(i) 返回i的二进制表示

hex(i) 返回i的十六进制表示

int(i) 将对象i转换为证书，失败时会产生一个ValueError异常，如果没有到整数的转换，会报TypeError异常，如果i是一个浮点数，会截取证书部分

int(s,base)将字符串s转换为证书，失败会产生ValueError异常，如果给定的可选的基参数，那么应该为2-36之间的证书

oct(i)返回i的8进制表示(字符串)

(3)给定两个或多个参数，但不是所有数据类型都支持，而对支持的这一数据类型，参数类型以及内涵都是变化的。

布尔类型True，False

浮点类型

float 表示双精度浮点数,浮点数表示的是近似值，而非实际值

complex

decimal.Decimal 需要高精度时(可表示小数点后28位)，并可以准确的表示循环小数（适用于财务计算）

计算机中使用基数2表示浮点数

混合运算

int和float生成float

float与complex生成 complex

decimal.Decimal是混合精度，只能用于decimal.Decimal和intS

浮点数

x=float()，返回0.0，x=float(i)返回该参数的一个拷贝，指定的任意数据类型都会尝试转换

在设计floatS的计算时，可能会生成NaN或无穷

int() 舍去小数部分

round() 四舍五入取整

math.ceil(),math.floor()返回向上，或向下转换为最接近的整数

float.hex()可以将浮点数以16进制形式表示为字符串，相反可以使用float.fromhex()

math.acos(x) 返回弧度的反余弦

mathi.acosh(x)返回x的反正切

math.asin(x)返回x的反正弦

math.asinh(x)返回x的反双曲正切

math.atan2(y,x) 返回y/x的反正切

math.atanh（x）返回x的反双曲正切

math.ceil(x)返回大于或等于x的最小整数

math.copysign（x,y），将x的符号设置为y的符号

math.cos(x) 返回弧度x的余弦

math.cosh(x) 返回弧度x的余弦值（角度）

math.degrees（r）将浮点数r从弧度转换为角度a

math.e  常数 e，2.7182818284590451

math.exp(x) 返回e的x次幂

math.fabs(x)返回|x|，浮点数x的绝对值

math.factorial(x)返回x！

math.floor(x) 返回小于或等于x的最小整数

math.fmod(x,y)生成x除以y后的余数,这会比用于浮点数的%更好的结果

math.frexp(x) 返回一个二元组,分别为x的指数整数与浮点数部分

math.fsum(a) 返回 iterable i的值进行求和，浮点数

math.hypot(x,y) 返回  x的平方+y的平方 开根号

math.isinf(x)如果浮点数x是+-无穷,返回true

math.isnan（x）如果x不是一个数字，返回true

math.ldexp（m,e）返回m*2的e次幂，翻转了frexp函数

math.log(x,b),math.log10(x),math.loglp(x)返回log以e为底（1+10）在x近似于0的时候更准确

math.modf(x)以floatS的形式返回x的小数与整数部分

复数

复数是固定的，其中存放的是一堆浮点数，一个表示实数部分，一个表示虚数部分

>>> z=10+2j
>>> z.real,z.imag
(10.0, 2.0)

　　math模块中数函数不能处理复数

十进制数

十进制数是使用decimal.Decimal()函数创建的，接受一个整数或字符串作为参数，但不能以浮点数作为参数，因为浮点数不够青雀

字符串

字符串是固定不变的，其存放的是Unicode字符序列

字符串跨行可以使用原字符r，同时也可以

>>> s="hello"+\
   "world"
>>> s
'helloworld'
>>> s=("hello"
	"world")
>>> s
'helloworld'

　　字符串比较

字符串比较可以使用<,<=,==,!=,>,>=,此操作符在内存中逐个字节对字符串进行比较

字符串比较存在两个问题：

1，有些unicode字符可以使用两种或更多种字节序列来表示。

　　可以使用:unicodedata模块以NFKD做第一个参数来调用unicodedata.normalize()，返回以UTF-8字节表示的字符串

2,有些字符串排序是特定于某种语言的。

　　可以自定义python的排序方法

字符串分片与步距

字符串的索引位置从0开始，直至字符串长度减1，但是使用负索引位置也是可以的

>>> s="hello world"
>>> s[0]
'h'
>>> s[-1]
'd'

3种分片操作

(1)seq可以是任意序列，列表，字符串，元组，start，end ，step必须是整数

step表示每隔step提取一次

seq[start]

seq[start:end]

seq[start:end:step]

>>> s[0:2]
'he'
>>> s[0:2:2]
'h'

(2)使用[:]

s[:]=s[0:len(s)] 用于提取整个序列，start省略时start=0，end省略时end=len（s），step省略时step=1

字符串中使用+进行连接，使用+=进行追加并不高效，最好使用str.join()方法

(3)当step为复数时，start=-1，终点索引默认为字符串起点前面

step不能 为0.如果不需要step，那么应该使用第二种写法

当step是-1的时候会翻转字符串

字符串操作符与方法

字符串是固定序列，所有可用于序列的功能都可用于字符串

in关系测试，+=链接,*复制，*=增强的赋值复制

字符串方法

s.capitalize()返回字符串s的副本，并将首字符变大写

s.center(width,char)返回s中间部分的一个子字符串，长度为width，并使用空格或者可选的char进行填充。

s.count(t,start,end)返回字符串s中子字符串t出现的次数

s.encode(encoding,err)返回bytes对象，该对象使用默认的编码格式或指定的编码格式或指定的编码格式来显示该字符串，并根据可选的err参数处理错误

s.endswith(x,start,end) 如果s以字符串x结尾，返回true，否则返回false

s.expandtabs(size)返回s的一个副本，其中的制表符使用8个或指定数量的空格替换

s.find(t,start,end)返回t在s中的最左位置，如果没有找到，就返回-1，使用str.rfind()可以发现相应的最右边位置

s.format(...)返回按给定参数进行格式化后的字符串副本

>>> s="'{0}' is good guy "
>>> s.format("hiuyeung",s)
"'hiuyeung' is good guy "

s.index(t,start,end)返回t在s中的最左边位置，如果没有找到，就产生一个ValueError异常，str.rindex()返回右边开始搜索

s.isalnum()，如果s非空，并且其中的每个字符都是字符数字的，就返回true

s.isalpha()，如果s非空，并且其中的每一个字符都是字符，返回true

s.isdecimal() ，如果s非空，并且每一个字符都是unical的基数为10的数字，就返回true

s.isdigit(),如果s非空，并且每一个字符都是Ascii数字，就返回true

s.isidentifier()，如果s非空，并且是一个有效的标识符，就返回true

s.islower(),如果s至少有一个可小写的字符，并且其所有课小写的字符都是小写的，就返回true

s.isnumeric() 如果s非空，并且其中的每个字符都是数值型的unicode字符，比如数字或者小数，就返回true

s.isprintable()如果s非空，并且其中的每个字符被认为是可打印的，包括空格，单不包括换行，就返回true

s.isspace()如果s非空，并且其中的每个字符都是空白字符，返回true

s.istitle(),如果s是一个非空的首字符大写的字符串，就返回true

s.isupper()，如果s至少有一个可大写的字符，并且所有可大写的字符都是大写，就返回true

s.join(seq)，返回seq中每个项链接起来后的结果，并以s在每两项之间分隔

s.ljust(width,char) 返回长度为width的字符串中左对齐的字符串s的一个副本，使用str.rjust()可以右对齐，str.center()可以中间对齐

s.lower() 将s中的字符串变为小写

s.maketrans()，与str.translate()类似

s.partition(t)返回包含3个字符串的元组--字符串s在t的最左边之前的部分，t，字符串s在t之后的部分，如果t不在s内，则返回s与两个空字符串

>>> s.partition(" ")
('hello', ' ', 'world')
>>> s.partition("o")
('hell', 'o', ' world')

　　

s.replace（t,u,n）返回s的一个副本，其中每个字符串（最多n个）t使用u替换

s.split（t,n）返回字符串列表，要求在字符串t处至多分隔n次，如果没有给定n，就可能分隔尽可能多次，如果t没有给定，就再空白处进行分隔，str.rsplit（）可以从右边进行分隔，只有给定n并且n小于可能分隔的最大次数时才起作用

s.splitlines(f)返回在行终结符处进行分隔产生的行列表

s.startswith（x,start,end）如果s(或者s的start:end分片)以字符串x开头，就返回true

s.strip（chars）返回s的一个副本,并将开始处与结尾处的chars符移除,s.lstrip,s.rtrip分别移除开始和结尾的相应字符

s.swapcase（）返回s的副本，并将其中的大写换小写，小写换大写

s.title() 返回s的副本，并将每个单子的首字符变大写，其他字符变小写

s.translate() 与str.maketrans（）类似

s.upper（）返回s的大写版本dde

s.zfill(w)返回s的副本，如果比w短,就再开始处增加0，使其长度为w

len()返回字符串长度，如果字符串是空，就返回0

+操作符用于字符串链接,如果需要链接大量的字符串，使用str.join效率更高，该方法以一个序列做为参数

并将其链接在一起存放在一个单独的字符串中

>>> t=["hello","world","baby"]
>>> "".join(t)
'helloworldbaby'
>>> " ".join(t)
'hello world baby'

　与reversed函数一起使用，实现字符串翻转

>>> t=["hello","world","baby"]
>>> " ".join(reversed(t))
'baby world hello'
>>> s="hello world"
>>> "".join(reversed(s))
'dlrow olleh'
>>>

　　*操作符提供字符串复制功能

>>> s="="*5
>>> s
'====='
>>> s*=10
>>> s
'=================================================='

　　in提供字符串关系操作

>>> s="hello world"
>>> "hello" in s
True
>>> "llo" in s
True
>>>

　　str.index,str.find 字符串超找功能

str.index(t,start,end)返回子字符串的索引位置,在失败时产生一个ValueError异常

str.find(s,start,end) 返回子字符串的索引位置，在失败时返回-1

>>> s="hello world"
>>> s.count("l")
3

字段名

>>> s="{who} is {age} years old!"
>>> s.format(who="My son",age="2")
'My son is 2 years old!'

>>> s="{0} is {age} years old!"
>>> s.format("My son",age="2")
'My son is 2 years old!'

#列表
>>> lst=["My son",2]
>>> s="{0[0]} is {0[1]} years old "
>>> s.format(lst)

#字典
>>> d=dict(name="My son",age=2)
>>> s="{0[name]} is {0[age]} years old!"
>>> s.format(d)
'My son is 2 years old!'

#当不指定索引时系统会自动从0开始进行赋值
>>> s="{}{}{}"
>>> s.format(1,2,3)
'123'

#对象
>>> import math
>>> s="{0.pi} is pi"
>>> s.format(math)
'3.141592653589793 is pi'

#映射拆分**locals()可以使用作用域内变量映射到一个字典中，这样就可以作为参数进行传递了
>>> name="my son"
>>> age=2
>>> s="{name} is {age} years old!"
>>> s.format(**locals())
'my son is 2 years old!'

　　

字符串填充

>>> s="hello world!"
>>> "{0:30}".format(s)
'hello world!                  '
>>> "{0:>30}".format(s)
'                  hello world!'
>>> "{0:.<30}".format(s)
'hello world!..................'
>>> "{0:.^30}".format(s)
'.........hello world!.........'
>>> "{0:.^{1}}".format(s,40)
'..............hello world!..............'

>>> "[{0:}],[{1:}]".format(250,-250)
'[250],[-250]'

显示符号
>>> "[{0:+}],[{1:+}]".format(250,-250)
'[+250],[-250]'
需要时显示符号
>>> "[{0:-}],[{1:-}]".format(250,-250)
'[250],[-250]'

>>> "[{0:x}]".format(16)
'[10]'
>>> "[{0:o}]".format(16)
'[20]'
>>> "[{0:b}]".format(16)
'[10000]'

>>> "[{0:#x}]".format(16)
'[0x10]'
>>> "[{0:#o}]".format(16)
'[0o20]'
>>> "[{0:#b}]".format(16)
'[0b10000]'