bestpotato
bestpotato

python自学笔记

python学习笔记

注释的使用

python中单行的注释是用#

# 这是一个注释
print("Hello, World!")

Python中多行的注释是用三个单引号‘’‘或三个双引号“”“将注释括起来

#单引号：
'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号 
这是多行注释，用三个单引号
'''
print("Hello, World!")

#双引号：
"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号 
这是多行注释，用三个双引号
"""
print("Hello, World!")

运算符

位运算符

将数字转换为二进制进行计算

a=60 ,b=13
即，
a = 0011 1100
b = 0000 1101

a&b = 0000 1100		#&：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0（交集）
a|b = 0011 1101		# | ：只要对应的二个二进位有一个为1时，结果位就为1（并集）
a^b = 0011 0001		#^：当两对应的二进位相异时，结果为1
~a  = 1100 0011		#~：对数据的每个二进制位取反,即把1变为0,把0变为1

<<  左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0
a = 0011 1100
a<<2
a = 11110000
a = 240

>>  右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数
a = 0011 1100
a>>2
a = 00001111
a = 15

逻辑运算符

and，or，not

and运算

逻辑量1 逻辑量2 结果
ture ture ture
ture false false
false ture false
false false false

or运算

逻辑量1 逻辑量2 结果
false false false
ture false ture
false ture ture
ture ture ture

成员运算符

in，not in

身份运算符

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。

算数运算符

/浮点数除法 100/5=20.0
//整数除法 100//5=20（向左取证） -3//2=-2
%模（求余） 9%4=1
**幂 2**3=8

关系运算符(还有大于等于)（单等=是赋值）

() xy x等于y “ABCD”==”ABCDEF” False

(!=) x!=y x不等于y “ABCD”!=”abcd” True

当字符串和字符串进行比较的时候，比较的是ASCII码表

例如：”123”与”23” 对第一个字符进行ASCII码表进行比较

​ 2的ASCII码表值大于1，所以

​ “123”<=”23”

运算符的优先级和结合性：

运算级 运算符 描述 结合性
1 +x,-x 正，负
2 x**y 幂 从右向左
3 x*y,x/y,x%y 乘，除，取模 从左向右
4 x+y,x-y 加，减 从左向右
5 x=y,x>y 比较 从左向右
6 not x 逻辑否 从左向右
7 x and y 逻辑与 从左向右
8 x or y 逻辑或 从左向右

基本数据类型

数字

数字类型：整型，浮点型，复数

整数（int）

默认情况下，整数为十进制

int函数：

>>>int(x,base = 10)

#x：字符串或数字

#base：进制数，默认十进制

>>>int('12',16)	#16进制的12转化成10进制数
18
>>> int('0xa',16)     #16进制的16转化成10进制数
10  
>>> int('10',8)  	#8进制的10转化成10进制数
8

浮点数（float）

取值范围与精度都有限制

小数：1.23,3.14，-9.01

科学计数法： 1.23e9 1.23*10**9

​ 1.2e-5 1.2*10负五次方

浮点数运算存在不确定尾数，有误差

round（0.1+0.2,2） 计算0.1+0.2，并保留两位小数

复数

​ 实部和虚部组成

​ 虚部用j来表示

​ a= complex(1,2)

​ a(1+2j)

常用的进制

二进制 0b或0B 0b10 2
八进制 0o或0O 0o10 8
十六进制 0x或0X 0x或0X 16

进制的转换

输入一个整数和进制，转换成十进制输出

s=input()
a=s.split(',')
print(int(a[0],int(a[1])))

hex 函数：用于将10进制整数转换成16进制，以字符串形式表示。

>>>hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'
>>> hex(12)
'0xc'
>>> type(hex(12))
<class 'str'>

oct 函数：将一个整数转换成 8 进制字符串。

>>> oct(10)
'012'
>>> oct(20)
'024'
>>> oct(15)
'017'

可以直接使用的数学函数：

作用 形式
abs 返回数字的绝对值 abs( x )
cmp 比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1 cmp( x, y )
int 将x转换为一个整数 int(x [,base ])
long 将x转换为一个长整数 long(x [,base ])
float 将x转换到一个浮点数 float(x )
complex 创建一个复数 complex(real [,imag ])
str 将对象 x 转换为字符串 str(x )
repr 将对象 x 转换为表达式字符串 repr(x )
eval 用来计算在字符串中的有效Python表达式,并返回一个对象 eval(str )
tuple 将序列 s 转换为一个元组 tuple(s )
list 将序列 s 转换为一个列表 list(s )
chr 将一个整数转换为一个字符 chr(x )
unichr 将一个整数转换为Unicode字符 unichr(x )
ord 将一个字符转换为它的整数值 ord(x )
hex 将一个整数转换为一个十六进制字符串 hex(x )
oct 将一个整数转换为一个八进制字符串 oct(x )
round 返回浮点数x的四舍五入值，n代表舍入到小数点后的位数 （若答案为两位小数，则用round无法保留超过两位的小数） round（x{ ，n}）
divmod 返回x和y的商和余数 divmod（x，y）

eval函数:用来执行一个字符串表达式，并返回表达式的值。

\>>>x = 7

\>>> eval( '3 * x' )

21

\>>> eval('pow(2,2)')	#pow是幂次

4

\>>> eval('2 + 2')

4

\>>> n=81

\>>> eval("n + 4")

85

pow函数：幂次

#pow(x,y):这个是表示x的y次幂。

<<<pow(2,4)

<<<16

#pow(x,y,z)：这个是表示x的y次幂后除以z的余数

<<<pow(2,4,5)

<<<1

<<

<<<16

pow(x,y,z)：这个是表示x的y次幂后除以z的余数

<<

<<<1

math模块：

模块提供了许多对浮点数的数学运算函数。（要先导入math模块）

import math

函数 作用 形式 备注
e 自然常数
pi 圆周率
ceil 返回数字的上入整数 math.ceil( x ) # x=13.5 输出：14 x=-45.17 输出：-45
exp 返回x的指数,e**x math.exp( x )
fabs 返回数字的绝对值 math.fabs( x ) #math.fabs(-10) 返回10.0
floor 返回数字的下舍整数 math.floor( x ) # x=13.5 输出：13 x=-45.17 输出：-46
log 返回 x 的自然对数 math.log(x[, base]) #base – 可选，底数，默认为 e
modf 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示 math.modf( x ) #math.modf(100.12) : (0.12000000000000455, 100.0)
acos 返回x的反余弦弧度值 acos(x)
asin 返回x的反正弦弧度值 acos(x)
atan 返回x的反正切弧度值 atan(x)
degrees 将弧度转换为角度 math.degrees(x)
radians 将角度转换为弧度 math.radians(x)

随机数模块：

random.random() 返回一个介于左闭右开[0.0,1.)区间的浮点数 random.random()
random.uniform(a,b) 返回一个介于[a,b]的浮点数 random.uniform(1,10)
random.randint(a,b) 返回[a,b]的一个随机整数 random.randint(15,30)
random.randrange([start],stop[,step]) 从指定范围内，获取一个随机数 random.randrange(10,30,2)
random.choice(sequence) 从序列中获取一个随机元素 random.choice([3,78,43,7])
random.shuffle(x) 用于将一个列表中的元素打乱，即将列表的元素随机排列 random.shuffle(l),l是序列
random.sample(sequence,k) 从指定序列中随机获取长度为k的序列并随机排列 random.sample([1,4,5,89,7],3)
random.seed(n) 对随机数生成器进行初始化的函数，n代表随机种子。参数为空时，随机种子为系统时间 random.seed(2)

shuffle函数：随机打乱列表顺序

>>> import random
>>> random.shuffle(t)
>>> t
[9, 4, 7, 5, 2, 3, 6]		#排列随机，使用一次变化一次
>>> random.shuffle(t)
>>> t
[3, 9, 4, 6, 7, 5, 2]

choice函数：随机选择列表中的元素

>>> t
[3, 9, 4, 6, 7, 5, 2]
>>> random.choice(t)
3
>>> random.choice(t)
4
>>> random.choice(t)
4

random函数：随机取得一个0-1之间的浮点数

>>> random.random()
0.01992198919664634
>>> random.random()
0.12040606605813042
>>> random.random()
0.5497462876939886

randint函数：在范围内随机取得一个整数

>>> random.randint(1,100)
54
>>> random.randint(1,100)
33
>>> random.randint(1,100)
44

seed函数：有一个确定的值，也会获得一个确定的值（确定的输入得到确定的输出）用seed（0），randint设置10个数据之后，再用seed（0）会输出同样的10个数据。如果用seed（1）就会生成新的数据

>>> random.seed(0)
>>> random.randint(1,100)
50
>>> random.randint(1,100)
98
>>> random.seed(0)
>>> random.randint(1,100)
50
>>> random.randint(1,100)
98

字符串

若文本中有双引号，可以用单引号括起来

若文本中有单引号，可以用双引号括起来

既有单引号又有双引号，可用三引号

布尔值

​ 布尔值：Ture，False

​ 逻辑运算和关系运算的结果是布尔值

转义字符

符号 作用 符号 作用
\ 反斜杠符号 \v 纵向制表符
’ 单引号 \t 横向制表符
‘’ 双引号 \r 回车
\a 响铃 \f 换页
\b 退格 \ooo 最多三位八进制，例如：\12代表换行
\n 换行 \xyy 十六进制，yy代表的字符，例如：\xOa代表换行

应用

\’ ：可以代表单引号’本身，并不作为字符串结束的标志

>>> 'It\'s a good day.'
"It's a good day."

\n:回车换行

>>> 'this is a line\nand another line'
'this is a line\nand another line'
>>> s = 'this is a line\nand another line'
>>> print(s)
this is a line
and another line

\t:制表符，制表位：让下一个字符出现在某一个特定的位置上

>>> s = 'this is a tab \tin the line'
>>> print(s)
this is a tab 	in the line

三引号的使用：（字符串内容可以跨行，换行的过程也会用反斜杠记录下来）

>>> s = '''i
love
you
baby
'''
>>> s
'i\nlove\nyou\nbaby\n'
>>> print(s)
i
love
you
baby

直接使用反斜杠\：（不进行换行，下一行的会紧紧连接在上一行上面）

>>> s = 'this\
 is\
 a\
 test.\
 '
>>> s
'this is a test. '

在单引号’前面加r：（会使字符串中的反斜杠\保留在字符串里）

r： 这个字符串表示原式的字符串

​ 这个字符串中的反斜杠\不会被当做转义字符的前缀

​ 字符串中的反斜杠\会被python的解释器重新还原成两个反斜杠\的转义字符的形态

>>> s = r'this\nis\na\ntest/'
>>> s
'this\\nis\\na\\ntest/'	#print\\时会输出\	
>>> print(s)
this\nis\na\ntest/

字符串运算符（可以正向也可以反向）

设s=”abcdefgh”

a b c d e f g h

0 1 2 3 4 5 6 7 正向

-8 -7 -6 -5 -4 -3 -2 -1 反向

索引 在【】中给出序号 s[0]=’a’ s=[-1]=’h’
切片 在【:】中给出切片序号范围 s[1:5]=’bcde’
+ 连接字符串 ‘hello’+‘world’=‘helloworld’
* 复制字符串 ‘ab’*=‘ababab’

若省略冒号后面的数字[a:]，则代表从第a+1个字符取到末尾字符

若省略冒号前面的数字[:b],则代表从第一个字符取到第b个字符

>>> '2020 welcome u'[4:]

' welcome u'

>>> '123456789'[:5]

'12345'

>>> '123456789'[2:]

'3456789'

在字符串的运算中

百分号%：字符串的格式化运算符

如果百分号的左边是一个字符串，它就要做字符号的百分号运算

在百分号前面的字符串里面放一些格式限定符，这些格式限定符将来会被百分号右边的数据给替换掉

>>> 'I am %d years old.'%18		
'I am 18 years old.'
>>> 'I am %d years old and weight %d kg.'%(18,65)
'I am 18 years old and weight 65 kg.'

>>> 'it is %.1fC.'%30.5		#%.nf ---保留n位小数，并且答案会进行四舍五入
'it is 30.5C.'
>>> 'it is %.1fC.'%30.1314
'it is 30.1C.'
>>> 'it is %.1fC.'%30.7914
'it is 30.8C.'
	
>>> ' I am %10d year old.'%18	#代表百分号到d（18）之间有8个空格
' I am         18 year old.'		（数据要输出的时候要保留多少位置）
>>> 'it is %10.1fC.'%30.7914
'it is       30.8C.'

f-string（f-fast）
new file:		
	name = 'Eric'
	age = 74
	print(f"Hello,{name}.You are {age}.")

	Hello,Eric.You are 74.

>>> f"{2*7}"	
'14'

>>> comedian = {
     'name':'Jame','age':74}
>>> f"The comedian is {comedian['name']},aged{comedian['age']}."	
'The comedian is Jame,aged74.'

字符串的格式化输出：

%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g %f和%e的简写
%G %F 和 %E 的简写
%p 用十六进制数格式化变量的地址

字符串函数：

capitalize函数：将字符串的第一个字母变成大写,其他字母变小写。对于 8 位字节编码需要根据本地环境。

center函数：返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。默认填充字符为空格。
	str.center(width[, fillchar])           
	width -- 字符串的总宽度。  
	 fillchar -- 填充字符。
        
count函数：用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
	str.count(sub, start= 0,end=len(string))		
	sub -- 搜索的子字符串  
	start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0
	end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

decode函数：以 encoding 指定的编码格式解码字符串。默认编码为字符串编码。（不会）

encode函数： 以 encoding 指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案。（不会）

endswith函数：用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。

startswith函数：用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。
	str.endswith(suffix[, start[, end]])
	suffix -- 该参数可以是一个字符串或者是一个元素。
	start -- 字符串中的开始位置。
	end -- 字符中结束位置。
		str = "this is string example....wow!!!"
		print(str.endswith('r',1,11))
		输出:Ture
		str = "this is string example....wow!!!"
		print(str.endswith('r',1,12))
		输出:False
            
expandtabs函数:把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。
	str.expandtabs(tabsize=8)
	tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数。
		str = "this is\tstring example....wow!!!"
		>>> print ("Double exapanded tab: " +  str.expandtabs(16))
		Double exapanded tab: this is         string example....wow!!!
		>>> print ("Double exapanded tab: " +  str.expandtabs(1))
		Double exapanded tab: this is string example....wow!!!
		>>> print ("Double exapanded tab: " +  str.expandtabs(8))
		Double exapanded tab: this is string example....wow!!!
		>>> print ("Double exapanded tab: " +  str.expandtabs(9))
  
find函数：在字符串当中查找子字符串的位置	s.find(sub,[,start[,end]])
rfind函数：在字符串当中查找子字符串最后出现的位置
>>> s = 'Lionel Messi'
>>> s
'Lionel Messi'
>>> s.find('Messi')		#第一个是零号，空格也占用一个编号
7
>>> s.find('on')
2
>>> s.find('aa')		#若要查找的子字符串不存在，则会返回-1
-1
>>> 'hello world'.find('l')	#当一个字符串内同时存在多个相同字符
2			#出现的编号是从左边开始，出现的第一个该字符的位置
>>> 'hello world'.find('l',3)	#第二个参数表示find函数从哪个编号开始找
3
>>> 'hello world'.find('l',4)
9

isalnum函数:检测字符串是否由字母和数字组成。
	如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
	str.isalnum()
		str = "this2009";  # 字符中没有空格
		print (str.isalnum())
 		输出：Ture
		str = "this is string example....wow!!!"	# 字符中有空格
		print (str.isalnum())
		输出：False
        
isalpha函数:检测字符串是否只由字母组成。
	如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。
	str.isalpha()

isdigit函数：检测字符串是否只由数字组成
str = "123456";  # Only digit in this string
print str.isdigit()	#Ture
str = "this is string example....wow!!!";
print str.isdigit()	#False

isdecimal函数：检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。
	注意:定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可。
	str.isdecimal()
		str = u"this2009";  
		print (str.isdecimal())
		输出：False
		str = u"23443434";
		print (str.isdecimal())
		输出:Ture
            
islower函数:检测字符串是否由小写字母组成
	str.islower()
    
isnumeric函数:检测字符串是否只由数字组成
	str.isnumeric()
    
isspace函数：检测字符串是否只由空格组成。
	str.isspace()
    
istitle函数：检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写
	str.istitle()
    
title函数：所有单词的首个字母转换为大写，其余字母均为小写
	str.title()
    
isupper函数：检测字符串中所有的字母是否都为大写
	str.isupper()
    
upper函数：将字符串中的小写字母转为大写字母
	str.upper()
    
join函数： 用于将序列中的元素以指定的字符连接生成一个新的字符串。
	返回通过指定字符连接序列中元素后生成的新字符串。	
	str.join(sequence)
	sequence -- 要连接的元素序列。
		str = "-"
		seq = ("a","b","c")
		print(str.join(seq))
		输出：a-b-c
        
ljust函数：返回一个原字符串左对齐,并使用填充字符填充至指定长度的新字符串。
rjust函数：返回一个原字符串右对齐,并使用填充字符填充至指定长度的新字符串。
	如果指定的长度小于原字符串的长度则返回原字符串。
	str.ljust(width[, fillchar])
	width -- 指定字符串长度。
	fillchar -- 填充字符，默认为空格。
		str = "this is string example....wow!!!"
		print (str.ljust(50, 'a'))
		输出：this is string example....wow!!!aaaaaaaaaaaaaaaaaa
		输出：aaaaaaaaaaaaaaaaaathis is string example....wow!!!（rjust）
        
lower函数：转换字符串中所有大写字符为小写	
	返回将字符串中所有大写字符转换为小写后生成的字符串。
	str.lower()
    
lstrip函数：用于截掉字符串左边的空格或指定字符
rstrip函数：用于截掉字符串末尾的空格或指定字符
strip函数：用于截掉字符串头尾的空格或指定字符
	str.lstrip([chars])
	chars --指定截取的字符。
	返回截掉字符串左边的空格或指定字符后生成的新字符串。
		str = "8888888this is string example...wow!!!8888888"
		print(str.lstrip("8"))
		输出：this is string example...wow!!!8888888
        
maketrans函数:创建字符映射的转换表，两个字符串的长度必须相同，为一一对应的关系
	str.maketrans(intab, outtab)
	intab -- 字符串中要替代的字符组成的字符串。
	outtab -- 相应的映射字符的字符串。
	返回字符串转换后生成的新字符串。	

replace函数：替换一段字符串为其他的内容	s.replace(old,new[,max])
old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次
>>> s  = ' hello world '
>>> s.replace(' ','-')		#将字符串中的空格全部转换成减号-
'-hello-world-'
>>> s  = ' hello world '
>>> s.replace(' ','--')	#将字符串中的空格全部转换成两个减号--
'--hello--world--'
>>> s  = ' hello world '
>>> s.replace(' ','')		#将字符串中的空格全部转换成空字符
'helloworld'		（即去掉字符串中的空格，但与strip不同，strip只去除两端的空格）
     
    
translate函数：根据参数table给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中
	str.translate(table)
	bytes.translate(table[, delete])    
	bytearray.translate(table[, delete]) 
	table -- 翻译表，翻译表是通过 maketrans() 方法转换而来。
	deletechars -- 字符串中要过滤的字符列表。
		intab = "abcdefg"
		outtab = "1234567"
		a = str.maketrans(intab,outtab)
		str = "this is a very beautiful girl"
		print(str.translate(a))
		输出：this is 1 v5ry 251uti6ul 7irl
        
split函数：通过指定分隔符对字符串进行切片
	如果第二个参数 num 有指定值，则分割为 num+1 个子字符串
	str.split(str="", num=string.count(str))
	str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
	num -- 分割次数。默认为 -1, 即分隔所有。
		str = "this is string example....wow!!!"
		print (str.split( ))       # 以空格为分隔符
		print (str.split('i',1))   # 以 i 为分隔符
		print (str.split('w'))     # 以 w 为分隔符
		输出：
		['this', 'is', 'string', 'example....wow!!!']
		['th', 's is string example....wow!!!']
		['this is string example....', 'o', '!!!']
        
splitlines函数： 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表
	如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符
	str.splitlines([keepends])
	keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')
	默认为 False，不包含换行符，如果为 True，则保留换行符
		>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
		['ab c', '', 'de fg', 'kl']
		>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(True)
		['ab c\n', '\n', 'de fg\r', 'kl\r\n']
                              
swapcase函数：用于对字符串的大小写字母进行转换。
	str.swapcase()
		str = "this is string example....wow!!!"
		print (str.swapcase())
		输出：THIS IS STRING EXAMPLE....WOW!!!

		str = "This Is String Example....WOW!!!"
		print (str.swapcase())
		输出：tHIS iS sTRING eXAMPLE....wow!!!

str函数：将对象转化为适于人阅读的形式
>>>s = 'RUNOOB'
>>> str(s)
'RUNOOB'
>>> dict = {
     'runoob': 'runoob.com', 'google': 'google.com'};
>>> str(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"

repr函数：将对象转化为供解释器读取的形式
>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {
     'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
                              
zfill函数:返回指定长度的字符串，原字符串右对齐，前面填充0。
	str.zfill(width)
		str = "this is string example from runoob....wow!!!"
		print("str.zfill:",str.zfill(50))
		输出：str.zfill: 000000this is string example from runoob....wow!!!

列表

列表定义

由一系列按照指定顺序排列的顺序组成的，列表当中的元素可以是不同的类型
列表是用方括号把字符括起来，字符串是用引号把字符括起来
列表之间的元素是用逗号进行分割

>>> a = 6	
>>> b= 8
>>> t = [a,b]
>>> t
[6, 8]
>>> t = [a+2,b-a]
>>> t
[8, 2]

>>> t = list('this is a strin')	
>>> t
['t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 's', 't', 'r', 'i', 'n']
#字符串当中的每一个字符都变成了列表当中的 item，空格也不例外

列表的常用函数

append函数：在列表末尾增加一个元素或一个列表(增加的元素为一个列表时，则新的元素为一个列表）

>>> t1
[1, 2, 3]
>>> t1.append(5)
>>> t1
[1, 2, 3, 5]

>>> t1 = [1,2,3]
>>> t1.append([4,5,6])
>>> t1
[1, 2, 3, [4, 5, 6]]		#有4个元素

extend函数：在列表后面增加元素或列表（类似于加号使用）

>>> t1
[1, 2, 3, 5]
>>> t1.extend([4,5,6])
>>> t1
[1, 2, 3, 5, 4, 5, 6]

insert函数：在某个位置之间插入一个元素或一个列表（当insert的位置超过最大的数之后，会加在最后）

>>> t1
[1, 2, 3, 5, 4, 5, 6]
>>> t1.insert(1,9)		#在编号1前面（第2个元素前面）增加一个元素9
>>> t1
[1, 9, 2, 3, 5, 4, 5, 6]

remove：删除值为多少的单个的元素

>>> t1
[1, 2, 3, [4, 5, 6]]
>>> t1.remove(2)
>>> t1
[1, 3, [4, 5, 6]]

>>> t = [1,2,3,1,2,3,1,2,3,1,2,3,1,2,3]
>>> t.remove(2)
>>> t
[1, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

pop函数：带有返回的删除参数所属元素（不带参数时删除最后一个）

>>> a = [1,2,3]
>>> a.pop()	#返回3
3
>>> a		#得到除了3,剩下的元素
[1, 2]

>>> a = [1,2,3,4,5,6,7,8,9]
>>> a.pop(3)
4
>>> a
[1, 2, 3, 5, 6, 7, 8, 9]

reverse函数：颠倒列表中函数的顺序

>>> a
[1, 2, 3, 5, 6, 7, 8, 9]
>>> a.reverse()
>>> a
[9, 8, 7, 6, 5, 3, 2, 1]

list函数：根据传入的参数创建一个新的列表（将元组或字符串转换为列表）

index函数：查找元素是否存在于列表里面（得到为该元素第一次出现的位置）

rindex函数：查找元素是否存在于列表里面（得到为该元素最后一次出现的位置）
该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。

>>> a
[9, 8, 7, 6, 5, 3, 2, 1]
>>> a.index(5)
4		#得出5在4号位上

列表函数的补充：

L.clear（） 移除列表L的所有元素
L.count（x） 计算列表L中x出现的次数
L.copy（） 列表L的备份
L.index（value【，start【，stop】】） 计算在指定范围内value的下标
L.sort（） 对列表元素排序
max（） 求最大值
min（） 求最小值
求得字符串（列表）长度

列表和字符串之间的转换：

>>> s = 'this is a test'			
>>> s.split()				#split函数：每一个单词都变成一个item
['this', 'is', 'a', 'test']				#（split可以通过空格进行分割）
>>> list(s)				#list函数：每一个字符都变成一个item
['t', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't']

>>> s = '12:35'		#split函数可以增加字符，字符代表什么作为分隔（可以是多个字符）
>>> s.split(':')
['12', '35']

>>> s = '12::35'
>>> s.split('::')
['12', '35']

>>> s = '12::35'		#两个分隔符若相连，则会有空的item
>>> s.split(':')
['12', '', '35']

>>> s = '12356982259265625212'		#字符多次出现则有多个分隔
>>> s.split('2')
['1', '35698', '', '59', '656', '5', '1', '']

>>> s = 'this is a test'		#join函数：把列表中的元素组成一个大的字符串
>>> t = s.split()
>>> t
['this', 'is', 'a', 'test']
>>> ' '.join(t)
'this is a test'
>>> t
['this', 'is', 'a', 'test']

列表切片

切片：在一个序列中取出一个连续的片段的操作

​ [a-1:b]既把输入值的第a到b项切出，方括号内的冒号形成了切片

​ 例：[2:6]

​ 0 1 2 3 4 5 6 7

​ 在第2个后面和第6个前面各切一刀 得：2 3 4 5

字符串取出一段还是字符串，列表取出一段还是列表

>>> month = ['JAN','FEB','MAR','APR','MAY','JUN','JUL','AUG','SEP','OCT','NOV','DEC']
>>> month
['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']
>>> month[4:8]
['MAY', 'JUN', 'JUL', 'AUG']

>>> 'zhejiang'[3:7]
'jian'
>>> 'zhejiang'[3:8]
'jiang'

用负数的切片可以省略字符串后面的字符 #空格也占一个编号

>>> '26C' [0:-1]
'26'
>>> '8C'[0:-1]
'8'
>>> '2020 welcome u '[4:-1]		#u后面还有一个空格
' welcome u'
>>> '2020 welcome u'[4:-1]
' welcome '

列表的元素可以是其他列表，但是要判断子列表是否在内，应该在列表中依然以列表形式存在

>>> t1 = [1,2,3]
>>> 1 in t1
True
>>> [1,2]in t1
False
>>> [1,2] in [[1,2],3]
True
>>> [1] in [1,2,3]
False

第一个就是第零号或第-n号

>>> t1 = [[1,2,3],[4,5],6]
>>> t1[0]
[1, 2, 3]
>>> t1[1]
[4, 5]
>>> t1[2]
6
>>>t1[-1]
[6]

>>> t1[0]

[1, 2, 3]

>>> t1[1]

[4, 5]

>>> t1[2]

6

>>>t1[-1]

[6]

可以通过下标来找到改列表中某个元素并改变它的值：

>>>s1 = [1,2,3,4,5]
>>>s1
[1, 2, 3, 4, 5]
>>> s1[1]
2
>>> s1[1] = 2.1
>>> s1
[1, 2.1, 3, 4, 5]

元组

元组tuple（列表和字符串以外的序列容器）

元组的字面量用的是圆括号（）

列表的字面量用的是方括号【】

（）圆括号表达元组 【】方括号表达列表 {}大括号表达集合和字典

元组是一种不可修改的数据（无法进行修改）

>>> t = [1,2,3]
>>> t
[1, 2, 3]
>>> p = (1,2,3)
>>> p
(1, 2, 3)
>>> t[0] = 4
>>> t
[4, 2, 3]
>>> p[0] = 4
'tuple' object does not support item assignment	#（元组不支持元素的赋值）
>>> min(p)
1
>>> len(p)
3
>>> p[0]
1

部分列表函数在元组中可以使用，但会对列表（元组）内部进行修改的函数在元组中不能使用

>>> p = (1,2,3)
>>> t.append(4)
>>> t
[4, 2, 3, 4]
>>> p.append(4)
'tuple' object has no attribute 'append'		#元组中没有append这种操作（属性）

将元组发给别人，别人无法修改元组的值

可以将列表数据转换成元组

>>> t = [1,2,3,4]
>>> t
>>> p = tuple(t)
>>> p
(1, 2, 3, 4)

如果有用逗号分隔的量，会被认为是元组

>>> p = 3,4
>>> p
(3, 4)

元组内置函数：

函数 作用
len(tuple) 计算元组元素个数。
min(tuple) 返回元组中元素最小值。
max(tuple) 返回元组中元素最大值。
tuple（iterable） 将可迭代系列转换为元组。

字典

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

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

d = {
     key1 : value1, key2 : value2 }

>>> d = {
     'one':1,'two':2}
>>> d
{
     'one': 1, 'two': 2}
两个条目：one和two
one是键，1是值，one对应1

创建了字典之后，可以不通过函数去增加，可以直接方括号赋值

>>> d['three'] = 3
>>> d['three']
3

删除条目：
用del语句，删除指定键的字典条目

>>> d
{
     'one': 1, 'two': 2, 'three': 3}
>>> del d['two']
>>> d
{
     'one': 1, 'three': 3}

但不能删除不存在的条目

>>> del d['four']
KeyError: 'four'

删除字典元素

dict = {
     'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

字典函数

clear：用于删除字典内所有元素

dict.clear()

copy：返回一个字典的浅复制

dict.copy()

fromkeys:创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值

dict.fromkeys(seq[, value])
	
seq = ('name', 'age', 'sex')
dict = dict.fromkeys(seq)
print ("新的字典为 : %s" %  str(dict))
#输出：新的字典为 : {'age': None, 'name': None, 'sex': None}
	
dict = dict.fromkeys(seq, 10)
print ("新的字典为 : %s" %  str(dict))
#输出：新的字典为 : {'age': 10, 'name': 10, 'sex': 10}

get：返回指定键的值，如果键不在字典中返回默认值

dict.get(key, default=None)

key – 字典中要查找的键。

key in dict		#判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。

default – 如果指定的键不存在时，返回该默认值值。

dict = {
     'Name': 'Runoob', 'Age': 27}
		
print ("Age 值为 : %s" %  dict.get('Age'))
print ("Sex 值为 : %s" %  dict.get('Sex', "NA"))
输出：Age 值为 : 27
输出：Sex 值为 : NA

items：以列表返回可遍历的(键, 值) 元组数组

dict.items()
		
dict = {
     'Name': 'Runoob', 'Age': 7}
print ("Value : %s" %  dict.items())
#输出：Value : dict_items([('Name', 'Runoob'), ('Age', 7)])

setfault：与find作用相似，若键不存在，输出default

dict.setdefault(key, default=None)
	key -- 查找的键值。
	default -- 键不存在时，设置的默认键值。

update：把字典参数dict2的key/value对更新到字典dict里

dict.update(dict2)
	dict2 -- 添加到指定字典dict里的字典。

values：返回迭代器

dict.values()
		
dict = {
     'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
print ("字典所有值为 : ",  list(dict.values()))
#输出：字典所有值为 :  ['female', 7, 'Zara']

pop：删除给定key的值，若没有key，则返回default
若要删除的key不存在，则需要添加默认值default，否则会报错

pop（key【，default】）
		 
>>> site= {
     'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
>>> pop_obj=site.pop('name')
>>> print(pop_obj)
#输出：
菜鸟教程

popitem：随机返回并删除字典中的最后一对键和值
若字典已空，调用此方法，就会报出KeyError异常

popitem（）	
		
site= {
     'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
pop_obj=site.popitem()
print(pop_obj)  
print(site)
#输出：	
('url', 'www.runoob.com')
{
     'name': '菜鸟教程', 'alexa': 10000}

len（dict）：计算字典元素个数，键的总数
str（dict）：输出字典，以可打印的字符串表示
type（variable）：返回输入的变量类型，如果变量是字典就返回字典类型

字典可以赋值，可以增加也可以修改（用方括号）

>>> d['one'] = 11
>>> d
{
     'one': 11, 'three': 3}

其他函数：

>>> len(d)	#获得字典中条目的数量
2
>>> min(d)	#求字典中最小的key
'one'

>>> sum(d)	#无法相加
unsupported operand type(s) for +: 'int' and 'str'

获得字典中某个key对应的值：get函数

>>> d
{
     'one': 11, 'three': 3}
>>> d.get('one')
11
>>> d.get('ok')		#当条目在字典中不存在时，会没有输出
>>> d.get('ok',1)		#当条目在字典中不存在时，会输出后面的数据
1

集合

用大括号（唯一性，丢入大量数据后剩下的数据唯一）
特点：
1.集合中没有重复的元素
2.集合中数的顺序不重要

不重复性：

>>> s = {
     1,2,3,3,4}
>>> s
{
     1, 2, 3, 4}

无序性：（程序员无法指定数的顺序）

>>> s = {
     1,3,2,5,4}
>>> s
{
     1, 2, 3, 4, 5}

可以增加元素（可变，但是不会重复）

>>> s = {
     1,3,2,5,4}
>>> s.add(0)
>>> s
{
     0, 1, 2, 3, 4, 5}
>>> s.add(3)
>>> s
{
     0, 1, 2, 3, 4, 5}

列表转换为集合：(set函数)

>>> t = [1,3,2,5,4]
>>> s1 = set(t)
>>> s1
{
     1, 2, 3, 4, 5}
>>> t
[1, 3, 2, 5, 4]

frozenset函数：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

>>>a = frozenset(range(10))     # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob') 
>>> b
frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合

两个空大括号连起来不是集合，是字典

>>> {
     }
{
     }
>>> type({
     })
<class 'dict'>

建立空的集合：

>>> set()
set()
>>> type(set())
<class 'set'>

集合内置函数：

copy函数：拷贝一个集合					
set.copy()

difference函数：返回集合的差集(会返回第一个集合中第二个集合没有的元素）				
set.difference(set)	

difference_update函数：移除第一个集合中第二个集合有的相同元素（直接在原来集合中移除元素，没有返回值）	
set.difference_update(set)

intersection函数：返回集合的交集（返回一个新的集合）				
set.intersection(set1, set2 ... etc)

intersection_update函数：返回集合的交集（返回一个新的集合）		
set.intersection_update(set1, set2 ... etc)

isdisjoint函数:判断两个集合是否包含相同的元素（不包含则返回True，包含则返回False）			
set.isdisjoint(set)
	
issubset函数：判断集合所有元素是否都包含在指定集合中（前面的集合是否包含在后面的集合里，是则返回True，否则返回False）		
set.issubset(set)
	
issuperset函数：判断集合所以元素是否都包含在原始的集合中(后面的集合是否包含在前面的集合里，是则返回True，否则返回False)		
set.issuperset(set)
	
symmetric_difference函数：返回两个集合中不重复的元素集合(返回一个新的集合)	
set.symmetric_difference(set)
	
symmetric_difference_update函数：移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中	
set.symmetric_difference_update(set)

set union函数：返回两个集合的并集，即包含所有集合的元素，重复的元素只会出现一次		
set.union(set1,set2...)
	set1----必需，合并的目标集合
	set2----可选，其他要合并的集合，可以多个，多个使用逗号隔开
	（返回一个新集合）

不能访问集合中的第n号元素

>>> s[0]
TypeError:'set' object does not support indexing（集合的对象不可以取下标）
无法指定集合中元素的位置，所以不能通过位置访问集合中的元素

可以输出集合中的元素：

>>>s = {
     1,2,3}
>>> for x in s:
	print(x)
1
2
3

可以判断集合中是否存在某个元素：

>>> s = {
     1,2,3,4,5,6,7,8,9}
>>> 3 in s
True
>>> 10 in s
False

可以判断两个集合是否相等

>>> s = {
     1,2,3,4,5,6,7,8,9}
>>> t = {
     1,2,3,5,6}
>>> s == t
False

判断集合之间的包含关系（包含或不包含）

>>> s = {
     1,2,3,4,5,6,7,8,9}
>>> ss = {
     1,3,4}	（真子集）
>>> ss < s
True
>>> {
     1,3,4}<ss
False
>>> {
     1,3,4}<=ss	（子集）
True

并集|：

>>> s1 = {
     1,2,3}
>>> s2 = {
     4,5,6}
>>> s1 | s2
{
     1, 2, 3, 4, 5, 6}

交集&：

>>> s1 = {
     1,2,3}
>>> s2 = {
     4,5,6}
>>> s3 = {
     1,2,4,5,7,8}
>>> s1 & s3
{
     1, 2}
>>> s1 & s2	#没有相同的元素（交集为空集）
set()

对称差^：把集合取并集，再去掉交集的部分

>>> s1
{
     1, 2, 3}
>>> s3
{
     1, 2, 4, 5, 7, 8}
>>> s1 ^ s3
{
     3, 4, 5, 7, 8}

在一个集合中去掉某个集合（差集）：

>>> s1
{
     1, 2, 3}
>>> s3
{
     1, 2, 4, 5, 7, 8}
>>> s1 - s3
{
     3}

条件控制

条件语句的三种格式：

1.基本的条件语句：
if 条件：
	语句块1

2. 有分支的条件语句：
if 条件：
	语句块1
else：
	语句块2

3.连缀的if-elif-else：
if 条件1：
	语句块1
elif 条件2：
	语句块2
...
elif 条件n：
	语句块n
else：
	语句块n+1

    
if逻辑表达式后面和else后面要加入冒号：
当逻辑表达式为真的时候，则会实行语句块1
当逻辑表达式为假的时候，则会实行语句块2
一次执行一项，要么执行语句块1，要么执行语句块2，不会同时执行
但是多次执行当中，语句块1,2都有可能会执行
当条件为0时，条件必然不成立
当条件为1时，条件必然成立

#例：
x = int(input())
if x>0:
    print('POS')		#要有tab进行缩进
else:					#else和if是并列的关系，当if的条件不满足时，会运行else的条件
    print('NEG')		#一个语句块可以进行多个操作（带多条语句）

同时输入两个数，输出更大的数据

x,y = map(int,input().split())		
if x>y:
    print(x)
else:
    print(y)

输入	3（x）	 5（y）
输出	5

嵌套条件例子：

x,y = map(int,input().split())	
if x>y:				#程序中可进行超过一次的if函数判断
    if x>0:				#嵌套的if语句
        print(x)			#可以在if后面增加if语句
    else:
        print(-x)
else:				#也可以在else后面增加if语句
    if y>0:
        print(y)
    else:
        print(-y)
输入：  -6（x）        -10（y）
输出：  6

循环语句

while语句

（可以配合continue和break进行使用）
无限循环：如果条件判断语句永远为 true，循环将会无限的执行下去 #以上的无限循环你可以使用 CTRL+C 来中断循环。

#具体解析例子：求一大串数据的平均数
s = 0 					#设s为和
n = 0					#设n为个数
while True:				#进入循环
    x = int(input())	#将数值输入
    if x!=-1:			#当输入的数值不等于-1时
        s += x			#和数每次加入数值		
        n += 1			#没加入一个数值，个数每次加一
    else:				#当输入的数值等于-1
        break			#打破循环
if n>0:					#如果输入数据的个数大于0
     print(s/n)			#输出总数除以个数的值（平均数）
else：					#如果输入的数据个数为0
     print（0）			#输出0

#实例：
#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

当循环条件为while 1时，循环必定成立

i = 1
while 1:            # 循环条件为1必定成立
    print i         # 输出1~10
    i += 1
    if i > 10:     # 当i大于10时跳出循环
        break

for语句

for的其中一种形式：
for后面的变量先被赋予一个值，并执行下面的代码块
然后被赋予变量的第二个值，并再次执行代码块
这个过程一直继续

for variable（变量） in 列表:
	语句块
#有多少个值，语句块就会重复多少次


#一般其他语言的方法：
x = int(input())				#输入一个x
isprime = True					#设置isprime为正确
for k in range(2,x):			#让k进入2~x-1的循环
    if x%k == 0:				#如果x除以k余数为0
        isprime = False			#（if语句与循环语句加起来即x有没有除1和本身之外的公约数）
        break					#当成立，则isprime为错误，并跳出循环
if isprime:						#如果isprime正确
   print('is prime')			#输出'is prime'
else:							#如果isprime错误
    print('is not prime')		#输出'is not prime'

#python的方法		for—else语句
x = int(input())		
isprime = True
for k in range(2,x):
    if x%k == 0:		
        isprime = False
        break
else:							#如果进入循环后，如果进行了break，则else不会被实行
    print('isprime')
#当输入的数值为素数，则输出isprime；若不是素数，则不会有任何输出

for—else：
如果这个循环正常结束，那么else后面的句子会执行；若有break，则else后面的句子不会执行

x = int(input())		#输入一个x
isprime = False		#给isprime赋值False
for k in range(2,x):		#使k进入循环
    if x%k == 0:		#当x除以k的余数为0时
        break		#退出循环
else:			#若无退出循环
    isprime = True		#则isprime赋值True
if isprime:			#如果isprime成立
    print('is prime')		#输出is prime
else:			#如果isprime不成立
    print('is not prime')	#输出is not prime

range函数：

产生数列

range(start,stop,step)			#括号内三个为参数
	start：计数从start开始。默认是从0开始。
	例如：range（5）等价于range（0,5）
	stop：计数到stop结束，但不包括stop。
	例如：list（range（0,5））是[0,1,2,3,4]没有5
	step：步长，默认为1.
	例如：range（0,5）等价于range（0,5,1）

>>> for i in range(5):
	print(i)

	
0
1
2
3
4

>>> list(range(5))
[0, 1, 2, 3, 4]

>>> list(range(2,10))	#两个参数range（a，b+1）（从a到b）
[2, 3, 4, 5, 6, 7, 8, 9]

>>> list(range(2,20,2))	#三个参数range（a，b+1，c）（从a到b，步长为c）
[2, 4, 6, 8, 10, 12, 14, 16, 18]

>>> list(range(21,2,-1))	#从大到小（21—2）的递减（公差为1）的列表
[21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3]

#得到1到100之间的所有的偶数：
1.>>> [i for i in range(1,101) if i%2==0]
2.>>> list(range(2,101,2))

循环嵌套

你可以在循环体内嵌入其他的循环体，如在while循环中可以嵌入for循环， 反之，你可以在for循环中嵌入while循环。

#while—while
i = 2
while(i < 100):
   j = 2
   while(j <= (i/j)):
      if not(i%j): break
      j = j + 1
   if (j > i/j) : print i, " 是素数"
   i = i + 1
print "Good bye!"


#for—for
for i in range(3):			#外层循环
    for j in range(10):			#内层循环
        print(str(i)+str(j),end=' ')
    print()				#换行

#运行结果：
00 01 02 03 04 05 06 07 08 09 
10 11 12 13 14 15 16 17 18 19 
20 21 22 23 24 25 26 27 28 29
#print语句执行次数：30


#嵌套循环也可for和while混合实现：
for i in range(1,4):
    j = 0
    while j<i:
        print(j,end=' ')
        j+=1
    print()

break语句：
break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。
break语句用在while和for循环中。
如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。

continue语句：
continue语句用来跳出本次循环剩余的语句，进行下一次的循环

continue语句和break语句的区别：
continue语句是跳过本次循环
break语句是跳出整个循环

pass语句：
pass 函数：不做任何事情，一般用做占位语句。

#例子：
for letter in 'Python':
   if letter == 'h':
      pass
      print '这是 pass 块'
   print '当前字母 :', letter
print "Good bye!"

输出：
当前字母 : P
当前字母 : y
当前字母 : t
这是 pass 块
当前字母 : h
当前字母 : o
当前字母 : n
Good bye!

迭代器与生成器

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器两种基本方法：iter（）和next（）

>>> list=[1,2]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2

当全部都输出时再打印会报错

Traceback (most recent call last):
  File "", line 1, in <module>
    print(next(it))
StopIteration

迭代器对象可以用for语句进行遍历：

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")
输出：1 2 3 4

也可以使用next函数：

import sys         # 引入 sys 模块
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()	#退出程序，退出程序后不会运行后面的代码
print("hi")		#因为退出了程序，所以不会输出（如果用break打破循环则会输出）
输出：
1
2
3
4

StopIteration函数：

异常用于标识迭代的完成，防止出现无限循环的情况

在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self
 
  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration
 
myclass = MyNumbers()
myiter = iter(myclass)
 
for x in myiter:
  print(x)

输出：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

生成器：

使用了yield函数

返回迭代器的函数，只能用于迭代操作

调用一个生成器函数，返回的是一个迭代器对象

使用yield来实现斐波那契数列：

import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()
输出：
0 1 1 2 3 5 8 13 21 34 55

函数

函数定义：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

#函数语句：
def函数名（参数列表）：
	函数体

# 计算面积函数：
def area(width, height):
    return width * height
 
def print_welcome(name):
    print("Welcome", name)
 
print_welcome("Runoob")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))

函数调用：

定义一个函数，完成该函数基本结构以后，可以用另一个函数调用执行
例如创建一个printme（）函数：

# 定义函数
def printme( str ):
   # 打印任何传入的字符串
   print (str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

#输出：
#我要调用用户自定义函数!
#再次调用同一函数

参数

调用函数时可使用的正式参数类型：

  • 必须参数
  • 关键字参数
  • 默认参数
  • 不定长参数

必须参数：

须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

def potato( str ):
   "打印任何传入的字符串"
   print (str)
   return

potato("你好")
#输出：你好

关键字参数：

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

def potato( str ):
   "打印任何传入的字符串"
   print (str)
   return

potato(str = "你好")
#输出：你好

默认参数：

调用函数时，如果没有传递参数，则会使用默认参数。

def potato( name, age = 25 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return

potato( age=16, name="hahaha" )			#均使用传递参数
print ("------------------------")
potato( name="good" )					#age没传递参数，使用默认参数
#输出：
#名字:  hahaha
#年龄:  16								#输出实参16
#------------------------
#名字:  good
#年龄:  25								#输出默认参数25

不定长参数：

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数

def potato( a, *b ):
   "打印任何传入的参数"
   print (a)
   print (b)
 
potato( 70, 60, 50 )
#输出: 
#70
#(60, 50)

如果在函数调用时没有指定参数，它就是一个空元组

def potato( a, *b ):
   "打印任何传入的参数"
   print (a)
   print (b)
 
potato(70)
#输出：
#70
#()

带两个*的参数（**）会以字典的形式导入：

def potato( a, **b ):
   "打印任何传入的参数"
   print (a)
   print (b)
 
potato(1, c=2,d=3)
#输出：
#1
#{'c': 2, 'd': 3}

强制位置参数：

斜杠/ 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式（对前面）
星号* 用来指明函数形参必须使用关键字参数，不能使用位置参数的形式（对后面）

实例：
a,b必须使用位置参数
c，d可以使用位置参数也可以使用关键字参数

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)

正确输入：
f(10, 20, 30, d=40, e=50, f=60)			#c,d可以使用位置参数也可以使用关键字参数
错误输入：
f(10, b=20, c=30, d=40, e=50, f=60)   	# b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)           	# e 必须使用关键字参数的形式

参数传递：

strings, tuples, 和 numbers 是不可更改的对象(不可变类型)
而 list,dict 等则是可以修改的对象(可变类型)
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
不可变：值传递，调用后不会改变实参
可变：形式传递，调用后会改变实参

def demo(a):
    print("原值: ",a)
    a += a
print("==========不可变==========")
b = "你好"
print("调用前:",b)
demo(b)
print("调用后:",b)
print("==========可变===========")
c = ["你好"]
print("调用前:",c)
demo(c)
print("调用后:",c)

#输出：
#==========不可变==========
#调用前: 你好
#原值:  你好
#调用后: 你好
#==========可变===========
#调用前: ['你好']
#原值:  ['你好']
#调用后: ['你好', '你好']

匿名函数：

lambda函数:创建匿名函数，不用def来定义函数

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

实例：

sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
输出：
相加后的值为 :  30
相加后的值为 :  40

return语句：

用于退出函数，选择性地调用方返回一个表达式

不带参数值的return语句返回None

#不带return函数：
def sum(a,b):
    c = a+b
    print("函数内:",c)
c = sum(20,50)
print("函数值:",c)
输出：
函数内: 70
函数值: None

#带return函数：
def sum(a,b):
    c = a+b
    print("函数内:",c)
    return c
c = sum(20,50)
print("函数值:",c)

输出：
函数内: 70
函数值: 70

数据结构

列表：

将列表当做堆栈使用：

堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）

用 append() 方法可以把一个元素添加到堆栈顶

用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来

实例：

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

>>> stack.append(6)

>>> stack.append(7)

>>> stack

[3, 4, 5, 6, 7]

>>> stack.pop()

7

>>> stack

[3, 4, 5, 6]

>>> stack.pop()

6

>>> stack.pop()

5

>>> stack

[3, 4]

将列表当作队列使用：

只是在队列里第一加入的元素，第一个取出来

在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")      # Terry arrives
>>> queue.append("Graham")      # Graham arrives
>>> queue.popleft()         # The first to arrive now leaves
'Eric'
>>> queue.popleft()         # The second to arrive now leaves
'John'
>>> queue              # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

>>> queue = deque([“Eric”, “John”, “Michael”])

>>> queue.append(“Terry”) # Terry arrives

>>> queue.append(“Graham”) # Graham arrives

>>> queue.popleft() # The first to arrive now leaves

‘Eric’

>>> queue.popleft() # The second to arrive now leaves

‘John’

>>> queue # Remaining queue in order of arrival

deque([‘Michael’, ‘Terry’, ‘Graham’])

列表推导式

每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。

返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表

希望表达式推导出一个元组，就必须使用括号

将列表中每个数值乘三，获得一个新的列表：

>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]

可以对同一个元素输出多个值：

>>>vec = [2, 4, 6]
>>>[[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]

>>> [3*x for x in vec]

[6, 12, 18]

可以对同一个元素输出多个值：

>>> vec = [2, 4, 6]

>>> [[x, x**2] for x in vec]

[[2, 4], [4, 16], [6, 36]]

可以对序列里每一个元素进行逐个调用某方法：

>>>freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> freshfruit
['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip()for weapon in freshfruit]		#调用序列中每一个元素，删除元素头尾的空格
['banana', 'loganberry', 'passion fruit']

>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip(' t')for weapon in freshfruit]
['banana', 'loganberry', 'passion frui']

序列中可以使用if子句来作为过滤器：

>>> best = [1,5,8]
>>> [3*x for x in best if x>3]		#if子句作为过滤器(过滤掉x<=3的元素)
[15, 24]

序列循环：

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> [x*y for x in a for y in b ]		
[4, 5, 6, 8, 10, 12, 12, 15, 18]
>>> [x*y for x in a for y in b if x>1]
[8, 10, 12, 12, 15, 18]
>>> [a[i]*b[i] for i in range(len(a))]
[4, 10, 18]

列表推导式可以使用复杂表达式或嵌套函数：

>>> [str(round(355/113,i)) for i in range(1,6)]	#i是小数个数
['3.1', '3.14', '3.142', '3.1416', '3.14159']

嵌套列表解析：

列表可以嵌套

建议一个3×4的矩阵：

>>> matrix = [
...   [1,2,3,4],
...   [5,6,7,8],
...   [9,10,11,12]
]
>>> matrix
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

将3×4矩阵转换为4×3矩阵：

>>> [[row[i] for row in matrix] for i in range(4)]	
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

也可以：

>>> transposed = []
>>> for i in range(4):
...   transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

另一种实现的方法：

>>> transposed = []
>>> for i in range(4):
...   # the following 3 lines implement the nested listcomp
...   transposed_row = []
...   for row in matrix:
...     transposed_row.append(row[i])
...   transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

del语句：

使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。

这与使用 pop() 返回一个值不同。（pop函数会返回一个元素）

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

也可以用del删除实体变量

>>> del a

集合的推导式：

>>> a = {
     x for x in 'abracadabra' if x not in 'abc'}
>>> a
{
     'r', 'd'}

字典的推导式：

>>> {
     x: x**2 for x in (2, 4, 6)}
{
     2: 4, 4: 16, 6: 36}

如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便：

>>> dict(sape=4139, guido=4127, jack=4098)
{
     'sape': 4139, 'jack': 4098, 'guido': 4127}

遍历技巧：

在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

>>> knights = {
     'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...   print(k, v)
...
gallahad the pure
robin the brave 

>>> a = {
     'ab':123,'cd':456,'ef':789}
>>> for x,y in a.items():
		print(x,y)
ab 123
cd 456
ef 789

在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...   print(i, v)
...
0 tic
1 tac
2 toe

同时遍历两个或更多的序列，可以使用 zip() 组合：

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...   print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

 

a = [1,2,3]
b = [4,5,6]
for x,y in zip(a,b):
  print("{0} != {1}".format(x,y))

要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：

>>> for i in reversed(range(1, 10, 2)):
...   print(i)
...
9
7
5
3
1

要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...   print(f)
...
apple
banana
orange
pear

模块

模块就是程序

导入模块：

1.import 模块名

2.from 模块名 import 函数名

from modname import name1[, name2[, … nameN]]

导入模块内的一些函数，可以直接使用

from modname import *

导入模块内所有的函数，但容易导致混乱一般不使用

3.import 模块名 as 新名字（更为方便）

导入数学库的sqrt函数：

>>> sqrt(100)
Traceback (most recent call last):
  File "", line 1, in <module>
    sqrt(100)
NameError: name 'sqrt' is not defined
>>> from math import sqrt
>>> sqrt(100)
10.0

>>>import math as m
>>>print(m.sqrt(100))

自定义模块：

1.模块程序和运行程序放在同一个文件夹，运行程序可以直接导入模块程序

2.模块程序和运行程序不在同一个文件夹内，运行程序时需要加入模块程序的路径

同一个文件夹
#模块程序：
def area(width,height):
    '''计算正方形面积'''
    w = width
    h = height
    a = w * h
    print (a)
#运行程序：
import love
love.area(10,10)

输出：100

加入测试代码：

#不用if __name__ == '__main__'（会运行测试代码）
def area(width,height):
    '''计算正方形面积'''
    w = width
    h = height
    a = w * h
    print (a)

def text():
    area(10,10)
    
text()

运行代码（会把运行测试代码）
import love
love.area(10,10)
输出：
100
100


#使用if __name__ == '__main__'（不会运行测试代码）
def area(width,height):
    '''计算正方形面积'''
    w = width
    h = height
    a = w * h
    print(a)

def text():
    area(10,10)
    
if __name__ == '__main__':
    text()

运行程序：
import love
love.area(10,10)
输出：
100

搜索路径：（\可以用/来代替）

sys模块 path变量

python会从以上路径去搜索是否拥有寻找的模块

找到会导入模块，找不到就会导入失败

一般模块可以放到site—packages文件夹

也可以自己建立文件夹来放入模块

>>> import sys
>>> sys.path
['', 'D:\\游戏啊\\python\\Lib\\idlelib', 'D:\\游戏啊\\python\\python37.zip', 'D:\\游戏啊\\python\\DLLs', 'D:\\游戏啊\\python\\lib', 'D:\\游戏啊\\python', 'D:\\游戏啊\\python\\lib\\site-packages']

没有相应路径时无法导入该文件的模块

>>> import love
Traceback (most recent call last):
  File "", line 1, in <module>
    import love
ModuleNotFoundError: No module named 'love'

append函数：可以加入该路径再导入模块（直接关闭后不会保存路径）

>>> sys.path.append("D:\\游戏啊\\python\\模块")
>>> sys.path
['', 'D:\\游戏啊\\python\\Lib\\idlelib', 'D:\\游戏啊\\python\\python37.zip', 'D:\\游戏啊\\python\\DLLs', 'D:\\游戏啊\\python\\lib', 'D:\\游戏啊\\python', 'D:\\游戏啊\\python\\lib\\site-packages', 'D:\\游戏啊\\python\\模块']

此时可以直接导入该路径内的模块：

>>> import love
>>> love.area(10,10)

remove函数：也可以删除掉路径

>>> sys.path.append("D:\\游戏啊\\python\\模块")
>>> sys.path
['', 'D:\\游戏啊\\python\\Lib\\idlelib', 'D:\\游戏啊\\python\\python37.zip', 'D:\\游戏啊\\python\\DLLs', 'D:\\游戏啊\\python\\lib', 'D:\\游戏啊\\python', 'D:\\游戏啊\\python\\lib\\site-packages', 'D:\\游戏啊\\python\\模块']
>>> sys.path.remove("D:\\游戏啊\\python\\模块")
>>> sys.path
['', 'D:\\游戏啊\\python\\Lib\\idlelib', 'D:\\游戏啊\\python\\python37.zip', 'D:\\游戏啊\\python\\DLLs', 'D:\\游戏啊\\python\\lib', 'D:\\游戏啊\\python', 'D:\\游戏啊\\python\\lib\\site-packages']
>>> import love
Traceback (most recent call last):
  File "", line 1, in <module>
    import love
ModuleNotFoundError: No module named 'love'

dir()函数：

内置函数dir（）可以找到模块内定义的所有名称，以一个字符串列表的形式返回

>>> dir(sys)
['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_enablelegacywindowsfsencoding', '_framework', '_getframe', '_git', '_home', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'get_asyncgen_hooks', 'get_coroutine_origin_tracking_depth', 'get_coroutine_wrapper', 'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace', 'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', 'set_coroutine_wrapper', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver']
>>> dir(love)
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'area', 'text']

包（package）：

1.创建一个文件夹，用于存放相应的模块，文件夹米名字即包的名字

2.文件夹内创建一个__init__.py的模块文件，内容可以为空

3.将相应模块放入文件夹中

输入和输出

格式化输出：

format()函数：

​ 基本格式：str.format（）

>>>x = 3.14159
>>>y = 2*x*3
>>>print("{0:.2f}{1:.2f}".format(x,y))
3.14 18.85

​ >>>y = 2x3

​ >>>print("{0:.2f}{1:.2f}".format(x,y))

​ 3.14 18.85

0和1表示format函数中的第一和第二个参数

.2f表示小数部分保留两位，四舍五入

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)

str()： 函数返回一个用户易读的表达形式。

repr()： 产生一个解释器易读的表达形式。

>>> hello = 'nihao,doubi\n ,buhao'	      
>>> a = str(hello)		      
>>> a		      
'nihao,doubi\n ,buhao'
>>> print(a)		      
nihao,doubi
 ,buhao

>>> hellos = repr(hello)		      
>>> print(hellos)		      
'nihao,doubi\n ,buhao'

输出平方和立方的表：

>>> for i in range(1,11):
	print(repr(i).rjust(2),repr(i**2).rjust(3),end = '')
	print(repr(i**3).rjust(4))

		      
 1   1   1
 2   4   8
 3   9  27
 4  16  64
 5  25 125
 6  36 216
 7  49 343
 8  64 512
 9  81 729
10 1001000

>>> for x in range(1, 11):
...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。

>>> print('{name}网址： {site}'.format(name='菜鸟教程', site='www.runoob.com'))
菜鸟教程网址： www.runoob.com

位置及关机子参数可以任意结合

>>> print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob', other='Taobao'))
站点列表 Google, Runoob, 和 Taobao。

如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。

最简单的就是传入一个字典, 然后使用方括号 [] 来访问键值 :

>>> table = {
     'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(table))
Runoob: 2; Google: 1; Taobao: 3

也可以通过在 table 变量前使用 ** 来实现相同的功能：

>>> table = {
     'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
Runoob: 2; Google: 1; Taobao: 3

读和写文件

open() 将会返回一个 file 对象，基本语法格式如下:

open(filename, mode)

filename：包含了你要访问的文件名称的字符串值。

mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。

r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

read函数：读取文件内的数据（若代入参数，参数为输出长度）

若使用UTF-8编码，则要输出encoding = “UTF-8”

f = open("D:\\游戏啊\\python\\你好.txt",encoding = "UTF-8")
str = f.read()
print(str)
f.close()
>>> f = open("D:\\游戏啊\\python\\你好.txt",encoding = "UTF-8")
>>> f.read(5)
'今天是星期'

当读取时，读到哪指针就会插到哪，下次直接读取会从指针位置读起

>>> f = open("D:\\游戏啊\\python\\你好.txt",encoding = "UTF-8")
>>> f.read()
'今天是星期几呢？\n今天是星期天'
>>> f.read()
''

tell函数：指出当前文件指针位置（UTF-8编码中文字符占三个字节）

>>> f = open("D:\\游戏啊\\python\\你好.txt",encoding = "UTF-8")
>>> f.read(5)
'今天是星期'
>>> f.tell()
15

seek函数：

移动文件中的指针位置，从from（0代表文件起始位置，1代表当前位置，2代表文件末尾）偏移offset个字节

f.seek(offset, from）
seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
seek(x,1) ： 表示从当前位置往后移动x个字符
seek(-x,2)：表示从文件的结尾往前移动x个字符（未懂）
>>> f = open("D:\\游戏啊\\python\\你好.txt",encoding = "UTF-8")
>>> f.seek(9)
9
>>> f.read()
'星期几呢？\n今天是星期天'

readline函数：读取文件中单独一行

f = open("D:\\游戏啊\\python\\你好.txt",encoding = 'UTF-8')
str = f.readline()
print(str)
f.close()
#输出：
#今天是星期几呢？

readlines函数：返回文件中包含的所有行

f = open("D:\\游戏啊\\python\\你好.txt",encoding = 'UTF-8')
str = f.readlines()
print(str)
f.close()
输出：
['今天是星期几呢？\n', '今天是星期天']

close函数：

处理完一个文件后，调用close来关闭文件并释放系统的资源

如果尝试再调用该文件，则会抛出异常

>>> f = open("D:\\游戏啊\\python\\你好.txt",encoding = 'UTF-8')
>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "", line 1, in <module>
    f.read()
ValueError: I/O operation on closed file.

write函数：使用close函数后txt文档中会出现“学习”两个字（要在w，a下才能输入）

>>> f = open("D:\\游戏啊\\python\\你好.txt","w",encoding = 'UTF-8')
>>> f.write("学习")
2	#输入的字符数
>>> f.close()
>>> f = open("D:\\游戏啊\\python\\你好.txt","a",encoding = 'UTF-8')
>>> f.write("我超喜欢的")
5
>>> f.close()

文本文档：
学习我超喜欢的

writelines函数：

向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符

输出文件内每一行内容：

>>> for each_line in f:

	print(each_line)
    
    
输出：
今天是星期几呢？

今天是星期天

分割文件：

将文件内内容分割并放到不同文件内

例：按girl和boy以及=分割，结果会生成六个文件夹

文件内容：

girl:Hello,how old are you?

boy:1000years old!

gilr:…

=========================================

girl:Excuse me,can you tell me the way to the ocean?

boy:Sorry, I do not know the way.

girl:Thank you._

========================================

boy:Hello

girl:Hello

def save_file(boy,girl,count):
    file_name_boy = "boy_" + str(count) + ".txt"
    file_name_girl = "girl_" + str(count) + ".txt"

    boy_file = open(file_name_boy,'w')
    girl_file = open(file_name_girl,'w')

    boy_file.writelines(boy)
    girl_file.writelines(girl)

    boy_file.close()
    girl_file.close()
        
f = open('test_2.txt',encoding = "UTF-8")

boy = []
girl = []
count = 1

for each_line in f:
    num = each_line.find("======")
    if num == -1:
        (role,line_spoken) = each_line.split(":",1)
        if role == "boy":
            boy.append(line_spoken)
        if role == "girl":
            girl.append(line_spoken)
    else:
        save_file(boy,girl,count)
        boy = []
        girl = []
        count += 1

save_file(boy,girl,count)
f.close()

pickle模块：（要以二进制形式）

实现了基本的数据序列和反序列化

通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

存放：pickle.dump(obj, file, [,protocol])

读取：x = pickle.load(file)

用pickle模块保存，可以永久保存

>>> city = ["s ads",54541,2434,[544,4545]]	
>>> import pickle
>>> pickle_file = open("city.pkl",'wb')		#后缀名可以自己输入
>>> pickle.dump(city,pickle_file)			#默认保存在当前文件中
>>> pickle_file.close()
>>> pickle_file = open("city.pkl",'rb')
>>> city2 = pickle.load(pickle_file)
>>> print(city2)
['s ads', 54541, 2434, [544, 4545]]

OS模块

使用os模块要先导入os模块

os模块：

getcwd函数：返回当前工作目录
>>> import os
>>> os.getcwd()
'D:\\游戏啊\\python'

chdir函数：更改目录位置
>>> os.chdir("D:/游戏啊/python/文件分割")
>>> os.getcwd()
'D:\\游戏啊\\python\\文件分割'

listdir函数：列举指定目录中的文件名（没有指定就会输出默认目录的文件）
>>> os.listdir()
['boy_1.txt', 'boy_2.txt', 'boy_3.txt', 'girl_1.txt', 'girl_2.txt', 'girl_3.txt', 'test.py', 'test_1.txt', 'test_2.txt', '~$test_1.txt']
>>> os.listdir("D:/游戏啊/python/idle  项目")
['hello.py', '五角星py.py', '圣诞树.py', '尝试.py', '新建文本文档.txt', '练习.py', '试题.py']

mkdir函数：相应路径会生成一个空白目录（不能在不存在的目录里面生成）
>>> os.mkdir("D:/游戏啊/A")
>>> os.mkdir("D:/游戏啊/python/A")

makedirs函数：递归生成多个目录（可以创建一个不存在的目录并在里面创建目录）
>>> os.makedirs("D:/游戏啊/python/创建目录/A")

remove函数：删除文件（无法删除目录）
>>> os.remove("D:/游戏啊/python/A/123.txt")

rmdir函数：删除目录（里面有文件则无法删除）
>>>os.rmdir("D:/游戏啊/python/A")

removedirs函数：递归删除目录（目录非空则抛出异常）
>>> os.mkdir("D:/游戏啊/python/A")
>>> os.mkdir("D:/游戏啊/python/A/B")
>>> os.removedirs("D:/游戏啊/python/A/B")	#A和B都删除

rename函数:将文件重命名（A改名为B）
>>> os.rename("D:/游戏啊/python/A","D:/游戏啊/python/B")

system函数：运行系统的shell命令
>>> os.system("cmd")	#打开cmd命令指示器
>>> os.system("calc")	#打开计算器

curdir函数：指代当前目录
>>> os.curdir
'.'
>>> os.listdir(os.curdir)	#输出当前目录的文件	
['boy_1.txt', 'boy_2.txt', 'boy_3.txt', 'girl_1.txt', 'girl_2.txt', 'girl_3.txt', 'test.py', 'test_1.txt', 'test_2.txt', '~$test_1.txt']

pardir函数：指代上一级目录
>>> os.pardir
'..'
>>> os.listdir(os.pardir)	#输出上一级目录的文件
['B', 'buhao.txt', 'DLLs', 'Doc', 'idle  项目', 'include', 'Lib', 'libs', 'LICENSE.txt', 'NEWS.txt', 'pycharm', 'python-3.7.0', 'python-3.7.0.rar', 'python.exe', 'python3.dll', 'python37.dll', 'pythonw.exe', 'Scripts', 'tcl', 'Tools', 'vcruntime140.dll', '你好.txt', '创建目录', '文件分割', '模块', '项目']

name函数：查看当前操作系统
>>> os.name
'nt'	#windows系统

os.path模块：

basename函数：去除目录路径，返回文件名
>>> os.path.basename("D:/游戏啊/python/A")
'A'

dirname函数：去除文件名，返回目录路径
>>> os.path.dirname("D:/游戏啊/python/A")
'D:/游戏啊/python'

join函数：将各部分组合成一个路径
>>> os.path.join("D:\\","A","B","C")
'D:\\A\\B\\C'

split函数：将文件名和路径分割
>>> os.path.split('D:\\A\\B\\C.txt')
('D:\\A\\B', 'C.txt')

splitext函数：将文件名与扩展名分离
>>> os.path.splitext('D:\\A\\B\\C.txt')
('D:\\A\\B\\C', '.txt')
>>> os.path.splitext('D:\\A\\B\\C')
('D:\\A\\B\\C', '')

getsize函数：返回文件的尺寸（大小）
>>> os.path.getsize("D:/游戏啊/python/模块/love.py")
196

getalime函数：返回文件最近访问时间
getclime函数：返回文件创建时间
getmlime函数：返回文件最近修改时间
>>> os.path.getatime("D:/游戏啊/python/模块/love.py")
1596863412.4359403	#返回浮点型秒数，可用time模块的gmtime或localtime换算
>>> os.path.getctime("D:/游戏啊/python/模块/love.py")
1596797589.1672275
>>> os.path.getmtime("D:/游戏啊/python/模块/love.py")
1596863412.4359403
#time模块
localtime是当地时间
gmtime是格林尼治时间
>>> import time
>>> time.gmtime(os.path.getmtime("D:/游戏啊/python/模块/love.py"))
time.struct_time(tm_year=2020, tm_mon=8, tm_mday=8, tm_hour=5, tm_min=10, tm_sec=12, tm_wday=5, tm_yday=221, tm_isdst=0)
2020年8月8日5点10分12秒
修改一下love.py
>>> time.localtime(os.path.getmtime("D:/游戏啊/python/模块/love.py"))
time.struct_time(tm_year=2020, tm_mon=8, tm_mday=11, tm_hour=0, tm_min=32, tm_sec=55, tm_wday=1, tm_yday=224, tm_isdst=0)
2020年8月11日0点32分55秒

相对路径：不是从根目录开始 #游戏啊/python/模块/love.py

绝对路径：从根目录开始 #D:/游戏啊/python/模块/love.py

返回True或False的函数：（os.path函数）

os.path.exists(path)				#路径存在则返回True,路径损坏返回False
os.path.isabs(path)					#判断是否为绝对路径
os.path.isfile(path)				#判断路径是否为文件
os.path.isdir(path)					#判断路径是否为目录
os.path.islink(path)				#判断路径是否为链接(快捷方式)
os.path.ismount(path)				#判断路径是否为挂载点(盘）
>>> os.path.ismount("D://")
True

全局变量和局部变量：

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

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

total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2 # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total
 
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)

异常

try—except函数：程序的保护机制，当程序出现异常时不会终止
当try步骤出现异常，则会跳过后面步骤，进入except步骤（如果try中有异常，try会进行到异常步骤）

#实例：
x = int(input())					#输出x
t = [1,2,3,4,5]						#给与t赋值为一个列表
try:								#尝试（检验程序是否出现异常）
    print(t[x])						#输出列表t的x标号（第x-1个）元素
    print('hello')					#输出‘hello’（若程序出现异常则跳过此步）
except:								#除外：（若程序出现异常则会跳到该步骤）
    print('x is not a valid index')	#输出'x is not a valid index'	
else:								#其他的：（若程序没出现异常，则输出完try后跳到此步骤）
    print('nothing')				#输出'nothing'
finally:							#最后：（无论程序中是否存在异常均会输出该步骤）
    print('anyway')					#输出'anyway'

输入的数据不同，会出现两种情况

异常情况：
try正常——try异常——except——finally
输入：10（在print(t[x])处出现异常）
输出：
x is not a valid index
anyway

正常情况：
try——else——finally
输入：3（在try步骤中没有出现异常）
输出：
4
hello
nothing
anyway

异常的处理：

try：			#做句子（步骤）
     语句块1		#可能步骤中会出现异常
except 异常类型1：		#一般会给出异常的类型
     语句块2
except 异常类型2：
     语句块3
...
except 异常类型N：
     语句块N+1
except：			#普通的except（无论什么异常都在这里进行）
     语句块N+2
else：			#若无异常则运行完try之后运行else
     语句块N+3
finally：			#无论有没有异常，都要运行finally
     语句块N+4

异常名称：

SystemExit				解释器请求退出
FloatingPointError		浮点计算错误
OverflowError			数值运算超出最大限制
ZeroDivisionError		除（或取模）零（所有数据类型）
Keyboardlnterrupt		用户中断执行（通常是输入^C）
ImportError				导入模块/对象失败
IndexError				序列中没有此索引（index）
RuntimeError			一般的运行时错误
AttributeError			对象没有这个属性
IOError					输入/输出操作失败
OSError					操作系统错误
KeyError				映射中没有这个键
TypeError				对类型无效的操作
ValueError				传入无效的参数

面向对象

类定义（语法格式）：

class ClassName:		#类名
    '''类的帮助信息'''	#类文档字符串	  
    <statement-1>		#由类变量、方法和属性等定义语句组成（可以用pass代替）
    .
    .
    .
    <statement-N>

类对象：

支持两种操作：属性引用和实例化

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'
# 实例化类
x = MyClass()
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

#输出：
#MyClass 类的属性 i 为： 12345
#MyClass 类的方法 f 输出为： hello world

类的特殊方法（构造方法）：

init(self)
类实例化时会自动调用__init__（）方法

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

类的方法与普通的函数只有一个特别的区别
它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
t = Test()
t.prt()
#输出：
#<__main__.Test instance at 0x100771878>
#__main__.Test

#self是类的实例，代表当前对象的地址，而self.class则指向类
#可以用别的单词代替self但一定要有self参数

类的方法：

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同
类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
# 实例化类
p = people('runoob',10,30)
p.speak()
#输出：
#runoob 说: 我 10 岁。

类的继承：

class DerivedClassName(BaseClassName1):
    <statement-1>
    .
    .
    .
    <statement-N>
#若子类出现与父类相同名字的方法或属性，则会覆盖父类的方法或属性
#即会用子类的方法或属性

如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法，或者不重写父类的构造方法。
子类不重写 init，实例化子类时，会自动调用父类定义的 init。

class Father(object):
    def __init__(self, name):
        self.name=name
        print ( "name: %s" %( self.name) )
    def getName(self):
        return 'Father ' + self.name
 
class Son(Father):
    def getName(self):
        return 'Son '+self.name
 
if __name__=='__main__':
    son=Son('runoob')
    print ( son.getName() )

#输出：
#name: runoob	(子类没有定义__init__，直接调用父类的__init__)
#Son runoob		(子类重新定义了getName)

super函数：调用父类(超类)的一个方法

super(type[, object-or-type])
#type -- 类。
#object-or-type -- 类，一般是 self

#实例1
class A:
     def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super().add(x)
b = B()
b.add(2)  #输出 3

#实例2
class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print ('Parent')
    
    def bar(self,message):
        print ("%s from Parent" % message)
 
class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent）
        #然后把类 FooChild 的对象转换为类 FooParent 的对象
        super(FooChild,self).__init__()    #应用了父类的__init__
        print ('Child')
        
    def bar(self,message):
        super(FooChild, self).bar(message)
        print ('Child bar fuction')
        print (self.parent)
 
if __name__ == '__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')

#输出：
#Parent
#Child
#HelloWorld from Parent
#Child bar fuction
#I'm the parent.

如果重写了__init__ 时，要继承父类的构造方法，可以使用 super 关键字：

super(子类，self).__init__(参数1，参数2，....)

还有一种经典写法：

父类名称.__init__(self,参数1，参数2，...)


#实例：
class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

#输出：
#调用子类方法
#调用父类方法

单继承实例：

#实例1：
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#实例2：
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
s = student('ken',10,60,3)
s.speak()

多继承实例：

class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

#输出：
#我叫 Tim，我是一个演说家，我演讲的主题是 Python

类的私有属性：

__private_attrs：两个下划线开头，声明该属性为私有
不能在类的外部被使用或直接访问
在类内部的方法中使用时 self.__private_attrs。

#实例：
class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)
 
counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  # 报错，实例不能访问私有变量

#输出：
1
2
2
（最后一个输出会报错，不能直接访问到私有变量）
Traceback (most recent call last):
  File "test.py", line 16, in <module>
    print (counter.__secretCount)  # 报错，实例不能访问私有变量
AttributeError: 'JustCounter' object has no attribute '__secretCount'

类的专有方法

（还没具体实例进行使用）

__init__ : 		构造函数，在生成对象时调用
__del__ : 		析构函数，释放对象时使用
__repr__ : 		打印，转换
__setitem__ : 	按照索引赋值
__getitem__: 	按照索引获取值
__len__: 		获得长度
__cmp__: 		比较运算
__call__: 		函数调用
__add__: 		加运算
__sub__:		减运算
__mul__: 		乘运算
__truediv__: 	除运算
__mod__: 		求余运算
__pow__: 		乘方

你可能感兴趣的:(自学,python)

  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • python os.environ 江湖偌大 python深度学习
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • python八股文面试题分享及解析(1) Shawn________ python
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • Python 实现图片裁剪（附代码） | Python工具 剑客阿良_ALiang
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • Python中深拷贝与浅拷贝的区别 yuxiaoyu.
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • Python编译器 鹿鹿~ Python编译器Pythonpython开发语言后端
    嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt
  • 一文掌握python面向对象魔术方法（二） 程序员neil pythonpython开发语言
    接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
  • 一文掌握python常用的list（列表）操作 程序员neil pythonpython开发语言
    目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
  • Python实现简单的机器学习算法 master_chenchengg pythonpython办公效率python开发IT
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
  • python中的深拷贝与浅拷贝 anshejd70787 python
    深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis
  • 用Python实现简单的猜数字游戏 程序媛了了 python游戏java
    猜数字游戏代码：importrandomdefpythonit():a=random.randint(1,100)n=int(input("输入你猜想的数字："))whilen!=a:ifn>a:print("很遗憾，猜大了")n=int(input("请再次输入你猜想的数字："))elifna::如果玩家猜的数字n大于随机数字a，则输出"很遗憾，猜大了"，并提示玩家再次输入。elifn
  • 用Python实现读取统计单词个数 程序媛了了 python游戏java
    完整实例代码：fromcollectionsimportCounterdefpythonit():danci={}withopen("pythonit.txt","r",encoding="utf-8")asf:foriinf:words=i.strip().split()forwordinwords:ifwordnotindanci:danci[word]=1else:danci[word]+=
  • apache ftpserver-CentOS config gengzg apache
    <server xmlns="http://mina.apache.org/ftpserver/spring/v1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://mina.apache.o
  • 优化MySQL数据库性能的八种方法 AILIKES sqlmysql
    1、选取最适用的字段属性 　　MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。因此，在创建表的时候，为了获得更好的 性能，我们可以将表中字段的宽度设得尽可能小。例如，在定义邮政编码这个字段时，如果将其设置为CHAR(255),显然给数据库增加了不必要的空间，甚至使用VARCHAR这种类型也是多余的，因为CHAR(6)就可以很
  • JeeSite 企业信息化快速开发平台 Kai_Ge JeeSite
    JeeSite 企业信息化快速开发平台 平台简介 JeeSite是基于多个优秀的开源项目，高度整合封装而成的高效，高性能，强安全性的开源Java EE快速开发平台。 JeeSite本身是以Spring Framework为核心容器，Spring MVC为模型视图控制器，MyBatis为数据访问层， Apache Shiro为权限授权层，Ehcahe对常用数据进行缓存，Activit为工作流
  • 通过Spring Mail Api发送邮件 120153216 邮件main
    原文地址：http://www.open-open.com/lib/view/open1346857871615.html 使用Java Mail API来发送邮件也很容易实现，但是最近公司一个同事封装的邮件API实在让我无法接受，于是便打算改用Spring Mail API来发送邮件，顺便记录下这篇文章。 【Spring Mail API】 Spring Mail API都在org.spri
  • Pysvn 程序员使用指南 2002wmj SVN
    源文件:http://ju.outofmemory.cn/entry/35762 这是一篇关于pysvn模块的指南. 完整和详细的API请参考 http://pysvn.tigris.org/docs/pysvn_prog_ref.html. pysvn是操作Subversion版本控制的Python接口模块. 这个API接口可以管理一个工作副本, 查询档案库, 和同步两个. 该
  • 在SQLSERVER中查找被阻塞和正在被阻塞的SQL 357029540 SQL Server
    SELECT  R.session_id AS BlockedSessionID ,          S.session_id AS BlockingSessionID ,          Q1.text AS Block
  • Intent 常用的用法备忘 7454103 .netandroidGoogleBlogF#
    Intent     应该算是Android中特有的东西。你可以在Intent中指定程序 要执行的动作（比如：view,edit,dial），以及程序执行到该动作时所需要的资料 。都指定好后，只要调用startActivity()，Android系统 会自动寻找最符合你指定要求的应用 程序，并执行该程序。 下面列出几种Intent 的用法 显示网页:
  • Spring定时器时间配置 adminjun spring时间配置定时器
    红圈中的值由6个数字组成，中间用空格分隔。第一个数字表示定时任务执行时间的秒，第二个数字表示分钟，第三个数字表示小时，后面三个数字表示日，月，年，< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" /> 测试的时候，由于是每天定时执行，所以后面三个数
  • POJ 2421 Constructing Roads 最小生成树 aijuans 最小生成树
    来源：http://poj.org/problem?id=2421 题意：还是给你n个点，然后求最小生成树。特殊之处在于有一些点之间已经连上了边。 思路：对于已经有边的点，特殊标记一下，加边的时候把这些边的权值赋值为0即可。这样就可以既保证这些边一定存在，又保证了所求的结果正确。 代码： #include <iostream> #include <cstdio>
  • 重构笔记——提取方法（Extract Method） ayaoxinchao java重构提炼函数局部变量提取方法
    提取方法（Extract Method）是最常用的重构手法之一。当看到一个方法过长或者方法很难让人理解其意图的时候，这时候就可以用提取方法这种重构手法。   下面是我学习这个重构手法的笔记：   提取方法看起来好像仅仅是将被提取方法中的一段代码，放到目标方法中。其实，当方法足够复杂的时候，提取方法也会变得复杂。当然，如果提取方法这种重构手法无法进行时，就可能需要选择其他
  • 为UILabel添加点击事件 bewithme UILabel
        默认情况下UILabel是不支持点击事件的，网上查了查居然没有一个是完整的答案，现在我提供一个完整的代码。   UILabel *l = [[UILabel alloc] initWithFrame:CGRectMake(60, 0, listV.frame.size.width - 60, listV.frame.size.height)]
  • NoSQL数据库之Redis数据库管理(PHP-REDIS实例) bijian1013 redis数据库NoSQL
    一.redis.php <?php //实例化 $redis = new Redis(); //连接服务器 $redis->connect("localhost"); //授权 $redis->auth("lamplijie"); //相关操
  • SecureCRT使用备注 bingyingao secureCRT每页行数
    SecureCRT日志和卷屏行数设置 一、使用securecrt时，设置自动日志记录功能。 1、在C:\Program Files\SecureCRT\下新建一个文件夹(也就是你的CRT可执行文件的路径），命名为Logs； 2、点击Options -> Global Options -> Default Session -> Edite Default Sett
  • 【Scala九】Scala核心三：泛型 bit1129 scala
    泛型类 package spark.examples.scala.generics class GenericClass[K, V](val k: K, val v: V) { def print() { println(k + "," + v) } } object GenericClass { def main(args: Arr
  • 素数与音乐 bookjovi 素数数学haskell
        由于一直在看haskell，不可避免的接触到了很多数学知识，其中数论最多，如素数，斐波那契数列等，很多在学生时代无法理解的数学现在似乎也能领悟到那么一点。     闲暇之余，从图书馆找了<<The music of primes>>和<<世界数学通史>>读了几遍。其中素数的音乐这本书与软件界熟知的&l
  • Java-Collections Framework学习与总结-IdentityHashMap BrokenDreams Collections
            这篇总结一下java.util.IdentityHashMap。从类名上可以猜到，这个类本质应该还是一个散列表，只是前面有Identity修饰，是一种特殊的HashMap。         简单的说，IdentityHashMap和HashM
  • 读《研磨设计模式》-代码笔记-享元模式-Flyweight bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java
  • PS人像润饰&调色教程集锦 cherishLC PS
      1、仿制图章沿轮廓润饰——柔化图像，凸显轮廓 http://www.howzhi.com/course/retouching/   新建一个透明图层，使用仿制图章不断Alt+鼠标左键选点，设置透明度为21%，大小为修饰区域的1/3左右（比如胳膊宽度的1/3），再沿纹理方向（比如胳膊方向）进行修饰。   所有修饰完成后，对该润饰图层添加噪声，噪声大小应该和
  • 更新多个字段的UPDATE语句 crabdave update
    更新多个字段的UPDATE语句                    update tableA a set (a.v1, a.v2, a.v3, a.v4) = --使用括号确定更新的字段范围
  • hive实例讲解实现in和not in子句 daizj hivenot inin
    本文转自：http://www.cnblogs.com/ggjucheng/archive/2013/01/03/2842855.html 当前hive不支持 in或not in 中包含查询子句的语法，所以只能通过left join实现。 假设有一个登陆表login(当天登陆记录,只有一个uid),和一个用户注册表regusers(当天注册用户，字段只有一个uid)，这两个表都包含
  • 一道24点的10+种非人类解法（2,3,10,10） dsjt 算法
    这是人类算24点的方法？！！！ 事件缘由：今天晚上突然看到一条24点状态，当时惊为天人，这NM叫人啊？以下是那条状态 朱明西 : 24点，算2 3 10 10，我LX炮狗等面对四张牌痛不欲生，结果跑跑同学扫了一眼说，算出来了，2的10次方减10的3次方。。我草这是人类的算24点啊。。 然后么。。。我就在深夜很得瑟的问室友求室友算 刚出完题，文哥的暴走之旅开始了 5秒后
  • 关于YII的菜单插件 CMenu和面包末breadcrumbs路径管理插件的一些使用问题 dcj3sjt126com yiiframework
    在使用 YIi的路径管理工具时，发现了一个问题。                    <?php         
  • 对象与关系之间的矛盾：“阻抗失配”效应[转] come_for_dream 对象
    概述   “阻抗失配”这一词组通常用来描述面向对象应用向传统的关系数据库（RDBMS）存放数据时所遇到的数据表述不一致问题。C++程序员已经被这个问题困扰了好多年，而现在的Java程序员和其它面向对象开发人员也对这个问题深感头痛。   “阻抗失配”产生的原因是因为对象模型与关系模型之间缺乏固有的亲合力。“阻抗失配”所带来的问题包括：类的层次关系必须绑定为关系模式（将对象
  • 学习编程那点事 gcq511120594 编程互联网
    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
  • Reverse Linked List II hcx2013 list
    Reverse a linked list from position m to n. Do it in-place and in one-pass. For example:Given 1->2->3->4->5->NULL, m = 2 and n = 4, return 
  • Spring4.1新特性——页面自动化测试框架Spring MVC Test HtmlUnit简介 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • Hadoop集群工具distcp liyonghui160com
        1. 环境描述 两个集群：rock 和 stone rock无kerberos权限认证，stone有要求认证。 1. 从rock复制到stone，采用hdfs Hadoop distcp -i hdfs://rock-nn:8020/user/cxz/input hdfs://stone-nn:8020/user/cxz/运行在rock端，即源端问题：报版本
  • 一个备份MySQL数据库的简单Shell脚本 pda158 mysql脚本
    　　主脚本（用于备份mysql数据库）： 　　该Shell脚本可以自动备份 数据库。只要复制粘贴本脚本到文本编辑器中，输入数据库用户名、密码以及数据库名即可。我备份数据库使用的是mysqlump 命令。后面会对每行脚本命令进行说明。 　　 1. 分别建立目录“backup”和“oldbackup” 　　#mkdir /backup 　　#mkdir /oldbackup 　
  • 300个涵盖IT各方面的免费资源（中）——设计与编码篇 shoothao IT资源图标库图片库色彩板字体
    A. 免费的设计资源 Freebbble:来自于Dribbble的免费的高质量作品。 Dribbble:Dribbble上“免费”的搜索结果——这是巨大的宝藏。 Graphic Burger:每个像素点都做得很细的绝佳的设计资源。 Pixel Buddha:免费和优质资源的专业社区。 Premium Pixels:为那些有创意的人提供免费的素材。
  • thrift总结 - 跨语言服务开发 uule thrift
    官网 官网JAVA例子 thrift入门介绍 IBM-Apache Thrift - 可伸缩的跨语言服务开发框架 Thrift入门及Java实例演示 thrift的使用介绍   RPC    POM： <dependency> <groupId>org.apache.thrift</groupId>
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他