2021-01-24

Python note

• 变量的类型是在赋予初始值的时候决定的，所以不需要事先声明数据类型

  Python 解释和运行系统会根据所赋予或设置的变量值来自动决定该变量的数据类型，其数据类型属于强类型

变量名称=变量值

number = 10

• 动态类型：

  编译时不会事先检查类型，在执行时才会按照变量值来决定变量类型，因此使用前不需要声明类型，同一个变量还可以赋予不同类型的值。

  Python

  • Python有垃圾回收（Garbage Collection）

• 静态类型：

  编译前会检查类型，因此变量使用前必须先进行明确的类型声明，执行时不能任意变更变量的类型。

  Java , C

Python数值数据类型

十进制（decimal）,二进制（Binary），十六进制（hexadecimal），八进制（octal）

浮点数	说明
25.3	带有小数点的正数
1.	1.0
5e4	50000.0

#所有的程序设计语言对浮点数运算都有精确度的问题
print(0.1+0.2)
>>>0.30000000000000004

#使用decimal模块进行小数运算
import decimal
num = decimal.Decimal("0.1")+decimal.Decimal("0.2")
print(num)
>>> 0.3
#使用round 函数强制小数点的指定位数
print(round(0.1+0.2,1))
>>>0.3

---

• Python 会自动将整数转换为浮点数再进行运算

num=5+0.3
>>>num=5.3
num=5+True
>>>num=6(整数)

• bool值的第一个字母应该大写

• 常数

常数拥有固定的数据类型和数值，变量与常数最大的差异在于变量的内容会随着程序的执行而改变，常数则固定不变。

Python格式化输入输出

1.“%”格式化输出

%[(name)][flags][width].[precision]typecode

• (name) 为命名
• flags 可以有 +，-，’ ‘或 0。+ 表示右对齐。- 表示左对齐。’ ’ 为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0 表示使用 0 填充。
• width 表示显示宽度
• precision 表示小数点后精度

#  "%s"代表字符串，"%d"代表整数,"%f"代表浮点数,"%e"代表浮点数，（科学计数法）
#  "%o"八进制  ， "%x"十六进制
#语法如下
print(格式化文本%(参数1，参数2，...,参数n))

例如：
score=100
print("大明的数学成绩：%d"%score)
>>>大明的数学成绩:100

• 格式化输出可以用来控制打印输出的位置，让输出的数据整齐排列

print("%5s的数学成绩是：%5.8f"%("Jenny",95))
print("%5s的数学成绩是：%5.2f"%("Anny",95))
>>>Jenny的数学成绩是：95.00000000
>>> Anny的数学成绩是：95.00
#上述格式化文本有两个参数，所以参数必须用括号括住
#  %5s表示输出时占用5个字符的位置，当实际输入少于5个文本时会在左边补上空位
#  %5.2f表示输出5位数的浮点数，小数点后占两位

2.format()函数输出

语法：{字段名：转换为指定格式}

相对于%格式化的方式，format()函数更加灵活

格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

format() 函数可以接受不限个参数，位置可以不按顺序。

print("{}是个好人".format("王冰冰"))
>>>王冰冰是个好人

score=100
print("Daming's math grade is {}".format(score))
>>> Daming's math grade is 100

format()函数相当具有弹性，它有两大优点

• 不需要理会参数数据类型，一律用{}表示
• 可使用多个参数同一个参数可以多次输出，位置可以不同

print("{0}今年{1}岁".format("wang",10))
#使用参数名称取代对应的参数
print("{name}今年{age}岁".format(name="wang",age=10))
#直接再数字编号后面加上冒号“：”可以指定参数的输出格式
print("|{0:5.2f}".format(5.5625))
#上例表示第一个参数取小数点后两位

#另外也可以搭配"<"">""^"来让字段左对齐，右对齐，居中
print("{0:10}成绩：{1:_^10}".format("Jennifer",95))
print("{0:10}成绩：{1:>10}".format("Curry",95))
print("{0:10}成绩：{1:*<10}".format("James",95))
>>>
wang今年10岁
wang今年10岁
| 5.56
Jennifer  成绩：____95____
Curry     成绩：        95
James     成绩：95********

Python format()

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:+.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:>10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)
11	'{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11)	1011 11 13 b 0xb 0XB

• ^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

• + 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格

• b、d、o、x 分别是二进制、十进制、八进制、十六进制。

• 此外我们可以使用大括号 {} 来转义大括号

3.input()函数

#input()函数语法如下
# 变量 = input(提示字符串)
# 提示字符串是一段告知用户输入的提示信息
score=input("Please input your IQ:")
print("{0:10}的IQ是:{1:_^10}".format("wang",score))
>>>
Please input your IQ:180
wang      的IQ是:___180____

#format() & input()
name=input("Please input your name:")
score=input("Please input your score:")
scool=input("Please input your scool:")
print("{0:10}{1:>8}{2:>6}".format("name","score","scool"))
print("{0:<10}{1:>7}{2:>7}".format(name,score,scool))
>>>
Please input your name:li

Please input your score:100

Please input your scool:buaa
name         score scool
li            100   buaa

4.数据类型转换

• Python语言中强制转换数据类型的内建函数有以下三种

• int()，float(),str()

• x = '5'
  num1 = 5 + int(x)
  num2 = 5 + float(x)
  num3 = 5 + float(x)
  print(num1)
  print(num2)
  print("输出的数值是"+str(num3))#强制转换为字符串类型
  >>>
  10
  10.0
  输出的数值是10.0
  

#数据类型转换
str = "{1}+{0} = {2}"
a = 150
b = "60"
print(str.format(a,b,a+int(b)))
>>>60+150 = 210

表达式与运算符

**	乘幂
/	除法
//	整数除法
%	求余数

• 如果运算结果并不赋值给其他变量，那么运算结果的数据类型将以操作数中数据类型占用内存空间最大的变量为主，另外，若结果会产生浮点数，Python会以浮点数形式输出结果。
• 若要赋值给某个变量，该变量占用的内存空间必须足够大。

”+“可以用来连接两个字符串

m=“abc”+“def” #结果： m=abcdef

赋值运算符”=“

• ”=“右边可以是常数，变量或表达式，左边只能是变量

#单一赋值
a=19
x=y=z=1000
x,y,z=10,20,30
sum=0;  index=12

#复合赋值
a+=1   #a=a+1
a%=b   #a=a%b

Python比较运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.
<>	不等于 - 比较两个对象是否不相等。python3 已废弃。	(a <> b) 返回 true。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

• 短路运算（Short-Circuit) : 以and为例若第一个判断为假，则不再进行判断，直接返回bool值

Python位运算符

按位运算符是把数字看作二进制来进行计算的。下表中变量 a 为 60，b 为 13，Python中的按位运算法则如下：

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^(XOR)	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

Python身份运算符

身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注： id() 函数用于获取对象内存地址。

Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符：

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 ‘AND’
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

读取CSV（Comma-Separated Values)文件

---

import csv
csv模块既可以读取CSV文件，也可以写入CSV文件，读取之前必须先打开CSV文件

with open ("source.csv",encoding="utf-8") as csvfile #打开文件指定为csvfile
	resder = csv.reader(csvfile)  #返回reader 对象
    for row in reader:
        print(row)

如果CSV文件与.py文件放在不同的文件夹中，就必须加上文件的完整路径

流程控制结构

1.条件结构

Python程序语言指定任何非0和非空（null）值为true，0 或者 null为false。

Python 编程中 if 语句用于控制程序的执行，基本形式为：

if 判断条件：
    执行语句……
    
else：
    执行语句……

其中"判断条件"成立时（非零），则执行后面的语句，而执行内容可以多行，以缩进来区分表示同一范围。

else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句。

if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。
当判断条件为多个值时，可以使用以下形式：

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。

import time 
print("现在时间：{}".format(time.strftime("%Y %A %B %c %d %H:%M:%S")))
h = int (time.strftime("%H"))
if h>5 and h<11 :
    print("Goodmorning!")
elif h>11 and h<18 :
    print("午安！")
else:
    print("晚安！")
    
>>>
现在时间：2021 Friday January Fri Jan 22 22:30:52 2021 22 22:30:52
晚安！




import calendar
 
cal = calendar.month(2021, 1)
print ("以下输出2016年1月份的日历:")
print (cal)

>>>
以下输出2016年1月份的日历:
    January 2021
Mo Tu We Th Fr Sa Su
             1  2  3
 4  5  6  7  8  9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31





help(strftime)
>>>
 strftime(...)
        strftime(format[, tuple]) -> string
        
        Convert a time tuple to a string according to a format specification.
        See the library reference manual for formatting codes. When the time tuple
        is not present, current time as returned by localtime() is used.
        
        Commonly used format codes:
        
        %Y  Year with century as a decimal number.
        %m  Month as a decimal number [01,12].
        %d  Day of the month as a decimal number [01,31].
        %H  Hour (24-hour clock) as a decimal number [00,23].
        %M  Minute as a decimal number [00,59].
        %S  Second as a decimal number [00,61].
        %z  Time zone offset from UTC.
        %a  Locale's abbreviated weekday name.
        %A  Locale's full weekday name.
        %b  Locale's abbreviated month name.
        %B  Locale's full month name.
        %c  Locale's appropriate date and time representation.
        %I  Hour (12-hour clock) as a decimal number [01,12].
        %p  Locale's equivalent of either AM or PM.
        
        Other codes may be available on your platform.  See documentation for
        the C library strftime function.

Time 模块

Time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的：

序号	函数及描述
1	time.altzone 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。
2	[time.asctime(tupletime]) 接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。
3	time.clock( ) 用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
4	[time.ctime(secs]) 作用相当于asctime(localtime(secs))，未给参数相当于asctime()
5	[time.gmtime(secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0
6	[time.localtime(secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。
7	time.mktime(tupletime) 接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。
8	time.sleep(secs) 推迟调用线程的运行，secs指秒数。
9	[time.strftime(fmt,tupletime]) 接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。
10	time.strptime(str,fmt=’%a %b %d %H:%M:%S %Y’) 根据fmt的格式把一个时间字符串解析为时间元组。
11	time.time( ) 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
12	time.tzset() 根据环境变量TZ重新初始化时间相关设置。

Time模块包含了以下2个非常重要的属性：

序号	属性及描述
1	time.timezone 属性 time.timezone 是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲<=0大部分欧洲，亚洲，非洲）。
2	time.tzname 属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。

---

日历（Calendar）模块

此模块的函数都是日历相关的，例如打印某月的字符月历。

星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数：

序号	函数及描述
1	calendar.calendar(year,w=2,l=1,c=6) 返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。
2	calendar.firstweekday( ) 返回当前每周起始日期的设置。默认情况下，首次载入 calendar 模块时返回 0，即星期一。
3	calendar.isleap(year) 是闰年返回 True，否则为 False。>>> import calendar >>> print(calendar.isleap(2000)) True >>> print(calendar.isleap(1900)) False
4	calendar.leapdays(y1,y2) 返回在Y1，Y2两年之间的闰年总数。
5	calendar.month(year,month,w=2,l=1) 返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。
6	calendar.monthcalendar(year,month) 返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。
7	calendar.monthrange(year,month) 返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12。
8	calendar.prcal(year,w=2,l=1,c=6) 相当于 print calendar.calendar(year,w=2,l=1,c=6)。
9	calendar.prmonth(year,month,w=2,l=1) 相当于 print calendar.month(year,month,w=2,l=1) 。
10	calendar.setfirstweekday(weekday) 设置每周的起始日期码。0（星期一）到6（星期日）。
11	calendar.timegm(tupletime) 和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）。
12	calendar.weekday(year,month,day) 返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）。

2.循环结构

Python 提供了 for 循环和 while 循环（在 Python 中没有 do…while 循环）:

循环类型	描述
while 循环	在给定的判断条件为 true 时执行循环体，否则退出循环体。（循环次数不确定）
for 循环	重复执行语句。(循环次数确定时)
嵌套循环	你可以在while循环体中嵌套for循环

循环控制语句

循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：

控制语句	描述
break 语句	在语句块执行过程中终止循环，并且跳出整个循环
continue 语句	在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
pass 语句	pass是空语句，是为了保持程序结构的完整性。

循环结构通常具备三个条件：

• 循环变量初始值
• 循环条件表达式
• 调整循环变量的增减值

count = 0
while (count < 9):
   print 'The count is:', count
   count = count + 1
 
print "Good bye!"
>>>
The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
Good bye!


# continue 和 break 用法
 
i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非双数时跳过输出
        continue
    print i         # 输出双数2、4、6、8、10
 
i = 1
while 1:            # 循环条件为1必定成立
    print i         # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环

循环使用 else 语句

在 python 中，while … else 在循环条件为 false 时执行 else 语句块

count = 0
while count < 5:
   print count, " is  less than 5"
   count = count + 1
else:
   print count, " is not less than 5"
>>>
0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5



#九九乘法表
for x in range (1,10):
    for y in range(1,10):
        print("{0}*{1}={2:^2}".format(y,x,x*y),end=" ")
    print()
>>>
1*1=1  2*1=2  3*1=3  4*1=4  5*1=5  6*1=6  7*1=7  8*1=8  9*1=9  
1*2=2  2*2=4  3*2=6  4*2=8  5*2=10 6*2=12 7*2=14 8*2=16 9*2=18 
1*3=3  2*3=6  3*3=9  4*3=12 5*3=15 6*3=18 7*3=21 8*3=24 9*3=27 
1*4=4  2*4=8  3*4=12 4*4=16 5*4=20 6*4=24 7*4=28 8*4=32 9*4=36 
1*5=5  2*5=10 3*5=15 4*5=20 5*5=25 6*5=30 7*5=35 8*5=40 9*5=45 
1*6=6  2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 7*6=42 8*6=48 9*6=54 
1*7=7  2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 8*7=56 9*7=63 
1*8=8  2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 9*8=72 
1*9=9  2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 



#range()
range(起始值（包括），终值（不包括），增减值)
range(2,10,2)
从2开始到10结束，每次增幅为2.

字符串的处理

Python 支持四种不同的数值类型：

• 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。
• 长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。
• 浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
• 复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

Python Number 类型转换

int(x [,base ])         将x转换为一个整数  
long(x [,base ])        将x转换为一个长整数  
float(x )               将x转换到一个浮点数  
complex(real [,imag ])  创建一个复数  
str(x )                 将对象 x 转换为字符串  
repr(x )                将对象 x 转换为表达式字符串  
eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象  
tuple(s )               将序列 s 转换为一个元组  
list(s )                将序列 s 转换为一个列表  
chr(x )                 将一个整数转换为一个字符  
unichr(x )              将一个整数转换为Unicode字符  
ord(x )                 将一个字符转换为它的整数值  
hex(x )                 将一个整数转换为一个十六进制字符串  
oct(x )                 将一个整数转换为一个八进制字符串  

• Python math 模块提供了许多对浮点数的数学运算函数。

• Python cmath 模块包含了一些用于复数运算的函数。

• cmath 模块的函数跟 math 模块函数基本一致，区别是 cmath 模块运算的是复数，math 模块运算的是数学运算。

• 要使用 math 或 cmath 函数必须先导入：

import math

Python数学函数

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,…)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,…)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
[round(x ,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)	返回数字x的平方根

Python三角函数

Python包括以下三角函数：

函数	描述
acos(x)	返回x的反余弦弧度值。
asin(x)	返回x的反正弦弧度值。
atan(x)	返回x的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	返回x的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(xx + yy)。
sin(x)	返回的x弧度的正弦值。
tan(x)	返回x弧度的正切值。
degrees(x)	将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)	将角度转换为弧度

Python 字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'
var2 = "Python Runoob

Python 访问字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号来截取字符串.

Python 转义字符

在需要在字符中使用特殊字符时，python 用反斜杠 ** 转义字符。如下表：

转义字符	描述
(在行尾时)	续行符
\	反斜杠符号
’	单引号
"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，y 代表 0~7 的字符，例如：\012 代表换行。
\xyy	十六进制数，以 \x 开头，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

Python字符串运算符

下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”：

操作符	描述	实例
+	字符串连接	>>>a + b ‘HelloPython’
*	重复输出字符串	>>>a * 2 ‘HelloHello’
[]	通过索引获取字符串中字符	>>>a[1] ‘e’
[ : ]	截取字符串中的一部分	>>>a[1:4] ‘ell’
in	成员运算符 - 如果字符串中包含给定的字符返回 True	>>>“H” in a True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	>>>“M” not in a True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	>>>print r’\n’ \n >>> print R’\n’ \n

Python 列表(List)

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

Python有6个序列的内置类型，但最常见的是列表和元组。

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = [‘physics’, ‘chemistry’, 1997, 2000] list2 = [1, 2, 3, 4, 5 ] list3 = [“a”, “b”, “c”, “d”]

与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。

• 列表的创建

#一维列表
data=[]
data1=[28,16]
data2=['1922',50,'bingbing']
data3=['English',[69,92]]

list1=[i for i in range (1,6)]

#二维列表
arr=[[None]*n for row in range (n)]

---

• 访问列表中的值

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符。

---

• 更新列表

你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：

---

• 删除列表元素

可以使用 del 语句来删除列表的元素，如下实例：

---

Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

如下所示：

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print x,	1 2 3	迭代

---

Python列表截取

Python 的列表截取实例如下：

>>>L = [‘Google’, ‘Runoob’, ‘Taobao’] >>> L[2] ‘Taobao’ >>> L[-2] ‘Runoob’ >>> L[1:] [‘Runoob’, ‘Taobao’] >>>

描述：

Python 表达式	结果	描述
L[2]	‘Taobao’	读取列表中第三个元素
L[-2]	‘Runoob’	读取列表中倒数第二个元素
L[1:]	[‘Runoob’, ‘Taobao’]	从第二个元素开始截取列表

---

Python列表函数&方法

Python包含以下函数:

序号	函数
1	cmp(list1, list2) 比较两个列表的元素
2	len(list) 列表元素个数
3	max(list) 返回列表元素最大值
4	min(list) 返回列表元素最小值
5	list(seq) 将元组转换为列表

Python包含以下方法:

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj) 将对象插入列表
6	[list.pop(index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse() 反向列表中元素
9	list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序

元组

• Python的元组与列表类似，不同之处在于元组的元素不能修改。

• 元组使用小括号，列表使用方括号。

• 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

创建空元组

tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号

tup1 = (50,)

元组与字符串类似，下标索引从0开始，可以进行截取，组合等

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
(‘Hi!’,) * 4	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print x,	1 2 3	迭代

---

元组索引，截取

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：

L = ('spam', 'Spam', 'SPAM!')

Python 表达式	结果	描述
L[2]	‘SPAM!’	读取第三个元素
L[-2]	‘Spam’	反向读取，读取倒数第二个元素
L[1:]	(‘Spam’, ‘SPAM!’)	截取元素

---

无关闭分隔符

任意无符号的对象，以逗号隔开，默认为元组。

---

元组内置函数

Python元组包含了以下内置函数

序号	方法及描述
1	cmp(tuple1, tuple2) 比较两个元组元素。
2	len(tuple) 计算元组元素个数。
3	max(tuple) 返回元组中元素最大值。
4	min(tuple) 返回元组中元素最小值。
5	tuple(seq) 将列表转换为元组。

Python 字典(Dictionary)

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

---

字典内置函数&方法

Python字典包含了以下内置函数：

序号	函数及描述
1	cmp(dict1, dict2) 比较两个字典元素。
2	len(dict) 计算字典元素个数，即键的总数。
3	str(dict) 输出字典可打印的字符串表示。
4	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。

Python字典包含了以下内置方法：

序号	函数及描述
1	dict.clear() 删除字典内所有元素
2	dict.copy() 返回一个字典的浅复制
3	[dict.fromkeys(seq, val]) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4	dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
5	dict.has_key(key) 如果键在字典dict里返回true，否则返回false
6	dict.items() 以列表返回可遍历的(键, 值) 元组数组
7	dict.keys() 以列表返回一个字典所有的键
8	dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2) 把字典dict2的键/值对更新到dict里
10	dict.values() 以列表返回字典中的所有值
11	[pop(key,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12	popitem() 返回并删除字典中的最后一对键和值。

函数

函数的声明，参数的使用，函数的主体与返回值

所谓模块（module)，是指具有特定功能的函数的组合。

#自定义函数语法
def 函数名称(参数1，参数2，···):
	程序语句区块
	return 返回值   #有返回值时才需要


# 形式参数：用来接收实际参数所传递的数据，进入函数主体参与指令的执行或运算。
# 实际参数：在函数调用中，将数据传递给自定义函数

Tips:
    我们可以使用type()函数来查询对象的数据类型。

函数调用

1.位置参数

def func(a,b,c=0):
	x=a+b+c
	return x
	
print(func(1,2,3))
print(func(1,2))

>>>
6
3

说明：没有提供实际参数时，以“默认参数=值”作为参数传入

调用参数时，如果不想按序一对一 的传递参数，就可以使用关键字参数。

2.关键字参数

def func(a,b,c=0):
	x=a+b+c
	return x
	
print(func(a=1,b=2,c=3))
print(func(a=1,2))

如果事先不知道要传入的参数有几个，那么可以在定义函数时在参数前面加上*号，表示该函数可以接收不确定个数的参数，传入的参数会视为一组元组，若**，则传入的参数视为一个字典

#tuple
def func(*num):
    total = 0
    for i in num:
        total +=i
    return total

print(func(1,2,3))
print(func(1,2))
>>>
6
3

#dict
def func(**num):
    return num

print(func(a=1,b=2,c=3))
print(func(a=1,b=2))

>>>
{
     'a': 1, 'b': 2, 'c': 3}
{
     'a': 1, 'b': 2}

3. Python的参数传递机制

Python的参数传递是使用不可变对象和可变对象来工作的。

在 python 中，类型属于对象，变量是没有类型的：

a=[1,2,3]

a=“Runoob”

以上代码中，[1,2,3] 是 List 类型，“Runoob” 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。类似 c++ 的值传递（Call by value)，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改形参 a 的值，只是修改另一个复制的对象，不会影响实参 a 本身。
• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。类似 c++ 的引用传递(Pass by reference)，如 列表，字典。如 fun（la），则是将 la 的地址传过去，对形参的变动连带者也会影响原来的实际参数的调用。

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

匿名函数

python 使用 lambda 来创建匿名函数。

• lambda只是一个表达式，函数体比def简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法

lambda函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

• 全局变量
• 局部变量

---

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。

如果在程序中有相同名称的全局变量和局部变量，就优先使用局部变量。在程序内优先使用局部变量，离开函数在函数体外时采用全局变量。

如果要在函数内使用全局变量，就必须在函数中用global来声明该变量。

递归函数—自己调用自己

• 递归之所以能实现，是因为函数的每个执行过程都在栈中有自己形参和局部变量的拷贝，而这些拷贝和函数的其他执行过程互不影响。
• 递归汇集的时间可以延迟到执行时才动态决定

def factorial(i):
    if i == 0:
        return 1
    else:
        num=i*factorial(i-1)
    return num

print(factorial(100))
>>>
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000


#用for循环代替递归
sum=1
n=int(input("Please input number:n="))
for i in range(0,n+1):
    for j in range(i,0,-1):
        sum*=j
    print("{0}!={1:5}".format(i,sum))
    sum=1
>>>
Please input number:n=7
0!=    1
1!=    1
2!=    2
3!=    6
4!=   24
5!=  120
6!=  720
7!= 5040

“尾部递归”（Tail Recursion）：程序的最后一条语句为递归调用，因为每次调用后，再回到前一次调用要执行的第一条语句就是return,所以后续不需要再执行任何语句了

#递归方式实现Hanoi塔问题
def hanoi(n,p1,p2,p3):
    if n==1:
        print("盘子从{}移动到{}".format(p1,p3))
    else:
        hanoi(n-1,p1,p3,p2)
        print("盘子从{}移动到{}".format(p1,p3))
        hanoi(n-1,p2,p1,p3)
j=int(input("请输入想要移动的盘子数："))
hanoi(j,1,2,3)
>>>
请输入想要移动的盘子数：4
盘子从1移动到2
盘子从1移动到3
盘子从2移动到3
盘子从1移动到2
盘子从3移动到1
盘子从3移动到2
盘子从1移动到2
盘子从1移动到3
盘子从2移动到3
盘子从2移动到1
盘子从3移动到1
盘子从2移动到3
盘子从1移动到2
盘子从1移动到3
盘子从2移动到3

排序

• 排序的过程中，计算机中数据的移动方式可分为直接移动和逻辑移动

直接移动：直接交换存储数据的位置。

逻辑移动：改变辅助指针指向的位置。

选择排序

#选择排序
#反复从未排序的数列中取出最小的元素，不断加入到另一个已排序的数列，最后结果即为已排序的数列。
def selectionSort(L):
    N=len(L)
    cc=0
    x=0
    for i in range(N-1):
        minL=i
        for j in range (i+1,N):
            x+=1
            if L[minL]> L[j]:
                minL = j
        L[minL],L[i] = L[i],L[minL]
        cc+=1
        print("第{}次排序的结果为：{}".format(cc,L))
    return L,x

a = [1,3,6,3,4,2,5]
print("排序前的顺序：{}".format(a))
L,x = selectionSort(a)
print("排序后：{}".format(L))
print("比较次数：{}".format(x))
>>>
排序前的顺序：[1, 3, 6, 3, 4, 2, 5]
第1次排序的结果为：[1, 3, 6, 3, 4, 2, 5]
第2次排序的结果为：[1, 2, 6, 3, 4, 3, 5]
第3次排序的结果为：[1, 2, 3, 6, 4, 3, 5]
第4次排序的结果为：[1, 2, 3, 3, 4, 6, 5]
第5次排序的结果为：[1, 2, 3, 3, 4, 6, 5]
第6次排序的结果为：[1, 2, 3, 3, 4, 5, 6]
排序后：[1, 2, 3, 3, 4, 5, 6]
比较次数：21

冒泡排序

#冒泡排序(交换排序)
#从第一个元素开始，比较相邻元素的大小，如果大小顺序有误，则对调后在进行下一个元素的比较，如此经过一次扫描后
#就可以确保最后一个元素位于正确的顺序，接着逐步进行第二次扫描，直到完成所有元素的排序关系为止。
def bubbleSort(L):
    N=len(L)
    cc=0
    x=0
    for i in range(N-1):
        for j in range (1,N-1):
            x+=1
            print("{},{}".format(L[j-1],L[j]))
            if L[j-1]> L[j]:
                L[j-1],L[j] = L[j],L[j-1]
        
        cc+=1
        print("第{}次排序的结果为：{}".format(cc,L))
    return L,x

a = [1,3,6,3,4,2,5]
print("排序前的顺序：{}".format(a))
L,x = bubbleSort(a)
print("排序后：{}".format(L))
print("比较次数：{}".format(x))
>>>
排序前的顺序：[1, 3, 6, 3, 4, 2, 5]
1,3
3,6
6,3
6,4
6,2
第1次排序的结果为：[1, 3, 3, 4, 2, 6, 5]
1,3
3,3
3,4
4,2
4,6
第2次排序的结果为：[1, 3, 3, 2, 4, 6, 5]
1,3
3,3
3,2
3,4
4,6
第3次排序的结果为：[1, 3, 2, 3, 4, 6, 5]
1,3
3,2
3,3
3,4
4,6
第4次排序的结果为：[1, 2, 3, 3, 4, 6, 5]
1,2
2,3
3,3
3,4
4,6
第5次排序的结果为：[1, 2, 3, 3, 4, 6, 5]
1,2
2,3
3,3
3,4
4,6
第6次排序的结果为：[1, 2, 3, 3, 4, 6, 5]
排序后：[1, 2, 3, 3, 4, 6, 5]
比较次数：30

排序函数–sorted()

#sorted，排序后产生新的对象
sorted(iterable,key=None,reverse=False)
#第一个参数：要排序的对象（可迭代）
#第二个参数：key接收函数作为参数，在排序之前会自动对每个元素执行一次key所指定的函数
#第三个参数：reverse=True 从大到小排序

x = "Everything is gonna be alright"
print(sorted(x.split("e"),key=str.lower,reverse=True))
>>>
['rything is gonna b', 'Ev', ' alright']


#sort方法只用于列表数据排序，排序后原列表发生改变
sort()
a=[1, 2, 3, 3, 4, 6, 5]
a.sort()