Python入门基础知识点实例分析

#Python语句中一般以新行作为语句的结束符。但是我们可以使用【斜杠（）】将一行的语句分为多行显示，
#语句中包含[],{}或()括号就不需要使用多行连接符。
#Python可以在同一行中使用多条语句，语句之间使用【分号(;)】分割
total=item_one+
item_two+
item_three
days=['Monday','Tuesday','Wednesday',
'Thursday','Friday']

#Python可以在同一行中使用多条语句，语句之间使用【分号(;)】分割。
importsys;x='runoob';sys.stdout.write(x+'n')

#Python可以使用【引号(')、双引号(")、三引号('''或""")】来表示字符串
word='word'
sentence="这是一个句子。"
paragraph="""这是一个段落。
包含了多个语句"""

#print默认输出是换行的，如果要实现【不换行需要在变量末尾加上逗号】。
printx,y

counter=100#赋值整型变量
miles=1000.0#浮点型
name="John"#字符串

二进制转换：
int('10',2)
>2
bin(10)
>'0b1010'
bin(10)[2:]

ord(c)#c为字符
#返回值：对应的十进制整数（ASCll数值）
int(c)#c为字符，转化为对应的数字

float('-inf')#最小值
-inf

a=b=c=1
a,b,c=1,2,"john"

all()#函数用于判断给定的可迭代参数iterable中的所有元素是否都为TRUE，如果是返回True，否则返回False。

#从左到右索引默认【0开始的】，最大范围是字符串【长度少1】
#从右到左索引默认【-1开始的】，最大范围是【字符串开头】
#第三个参数，参数作用是【截取的步长】
s="a1a2an"#n>=0

向上取整：math.ceil()
向下取整：math.floor()、整除"//"
四舍五入：round()——奇数向远离0取整，偶数去尾取整；或言之：奇数进位，偶数去尾
向0取整：int()

tinylist=[123,'john']
printlist[0]#输出列表的第一个元素
printlist[1:3]#输出第二个至第三个元素
printlist[2:]#输出从第三个开始至列表末尾的所有元素

#二维数组
num_list=[[0]*5foriinrange(2)]
dp=[[1]*n]+[[1]+[0]*(n-1)for_inrange(m-1)]

clone_node.neighbors=[self.cloneGraph(n)forninnode.neighbors]

#加号+是列表连接运算符，星号*是重复操作
printtinylist*2#输出列表两次
printlist+tinylist#打印组合的列表

list.append('Google')#使用append()添加元素
dellist[2]			#可以使用del语句来删除列表的元素
list.pop(3)			#指定pop参数，将会删除该位置的元素；无参数时默认删除最后一个元素

list.append(sublist)#引用传递
list.append([]+sublist)#值传递
list.append(list(path))

len([1,2,3])	3	#长度
[1,2,3]+[4,5,6]	[1,2,3,4,5,6]	#组合
['Hi!']*4	['Hi!','Hi!','Hi!','Hi!']	#重复
3in[1,2,3]	True	#元素是否存在于列表中
forxin[1,2,3]:printx,	123	#迭代

[::-1]#数组反转

max(list)#求list的最大值

sum(sp[i]foriinrange(n))#求和
sum(sinjewelsSetforsinstones)

nums.sort()#排序
score.sort(reverse=True)
list有一个sort方法，list.sort()将list进行排序，返回None
sort(*,key=None,reverse=False)
key是一个函数，这个函数的作用是从list的每个元素中提取用于当作排序依据的属性
默认是从小到大，即reserve为False的时候，如果reserve为True，排列顺序就是从大到小
deff(item):
returnitem[1]
list.sort(key=f)
list.sort(key=lambdaitem:item[0])

sorted(iterable,*,key=None,reverse=False)#默认正序排列
sorted(dict.items(),key=lambdaitem:item[0])
res=sorted(hash,key=lambdaword:(-hash[word],word))#第一个参数-hash[word]即单词出现次数的相反数
#当词频相同时，用第二个参数word进行排序，即字母正序排列

列表解析ListComprehensions
表达式：[expressionforiter_valiniterableifcond_expr]
[expression]：最后执行的结果
[foriter_valiniterable]：这个可以是一个多层循环
[ifcond_expr]：两个for间是不能有判断语句的，判断语句只能在最后；顺序不定，默认是左到右。

print[(x,y)forxin[1,2]foryin[3,4]]

for(k1,v1),(k2,v2)inzip(dict_one,dict_two):#遍历两个list或者dict

foriteminproduct([1,2],[10,20]):#对矩阵做笛卡尔积
print(item)
fori,jinproduct(range(m),range(n)):


neighbors=[(1,0),(1,-1),(0,-1),(-1,-1),(-1,0),(-1,1),(0,1),(1,1)]
forneighborinneighbors:
	r=(row+neighbor[0])
	c=(col+neighbor[1])
foru,vinneighbors:
	
s=[1,2,3,4,5]
#从指定索引1开始
forindex,valueinenumerate(s,1):

list(str(n))#int转化为字符串，转化为list

next(wordforword,finfreq.items()iff==maxFreq)#next()取list第一个值

map(max,grid)#求每行的最大值
map(max,zip(*grid))#求每列的最大值
strs=map(str,nums)#转换为list(str)
r1,m1=map(int,num1[:-1].split('+'))#list(str)转化为list(int)
list(map(list,numSet))

>>>a=[1,2,3]
>>>b=[4,5,6]
>>>c=[4,5,6,7,8]
>>>zipped=zip(a,b)#返回一个对象
>>>zipped

>>>list(zipped)#list()转换为列表
[(1,4),(2,5),(3,6)]
>>>list(zip(a,c))#元素个数与最短的列表一致
[(1,4),(2,5),(3,6)]
>>>a1,a2=zip(*zip(a,b))#与zip相反，zip(*)可理解为解压，返回二维矩阵式
>>>list(a1)
[1,2,3]
>>>list(a2)
[4,5,6]

#元组用()标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
tinytuple=(123,'john')

#字典用"{}"标识。字典由索引(key)和它对应的值value组成。
dict={}
dict['one']="Thisisone"
dict[2]="Thisistwo"

#值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。用列表就不行
dict[tuple(count)]

#以列表返回字典中的所有值
dict.values()
list(dict.values())

forkeyindict:
print(key)

tinydict={'name':'runoob','code':6734,'dept':'sales'}
printdict['one']#输出键为'one'的值
printdict[2]#输出键为2的值

printtinydict#输出完整的字典
printtinydict.keys()#输出所有键
printtinydict.values()#输出所有值
maxFreq=max(freq.values())#求value的最大值

tinydict['Age']=8#更新
tinydict['School']="RUNOOB"#添加

deltinydict['Name']#删除键是'Name'的条目
tinydict.clear()#清空字典所有条目
deltinydict#删除字典

defaultdict(list)defaultdict(int)#defaultdict类的初始化函数接受一个类型作为参数，当所访问的键不存在的时候，可以实例化一个值作为默认值：

count.get(c,0)#默认值为0

items():返回所有（key，value）元组的数组,类似于‘列表’
[sfors,cincnt.items()ifc==maxCnt]#遍历dict

dict排序
sorted(dict.items(),key=lambdaitem:item[0])

items=[(-val,key)forkey,valincount.items()]#变更为tuple
forval,keyinsorted(items):#遍历排序后的tuple

parame={value01,value02,...}
或者
set(value)

s.add(x)

s.update(x)#参数可以是列表，元组，字典等

s.remove(x)

s.discard(x)

len(s)

s.clear()

xins

forkeyinset:
print(key)

ifnum==3:#判断num的值
print'boss'elifnum==2:
print'user'elifnum==1:
print'worker'elifnum

i=1
whilei0:#非双数时跳过输出
continue
printi#输出双数2、4、6、8、10

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

flag=1
while(flag):print'Givenflagisreallytrue!'

fruits=['banana','apple','mango']
forfruitinfruits:#第二个实例
print('当前水果:%s'%fruit)

fruits=['banana','apple','mango']
forindexinrange(len(fruits)):
print('当前水果:%s'%fruits[index])

foriinreversed(range(length-1)):#逆序

forletterin'Python':#第一个实例
ifletter=='h':
break
print'当前字母:',letter

fori,chinenumerate(s):
	iffrequency[ch]==1:
		returni

diff=[(a,b)fora,binzip(s,goal)ifa!=b]

+	字符串连接	
>>>a+b
'HelloPython'

*	重复输出字符串	
>>>a*2
'HelloHello'

[]	通过索引获取字符串中字符	
>>>a[1]
'e'

[:]	截取字符串中的一部分	
>>>a[1:4]
'ell'

in	成员运算符-如果字符串中包含给定的字符返回True	
>>>"H"ina
True
notin	成员运算符-如果字符串中不包含给定的字符返回True	
>>>"M"notina
True

r/R	原始字符串-原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	
>>>printr'n'
n
>>>printR'n'
n

strs='abcd'
forchinstrs:
print(ch)

strs='abcd'
forindexinrange(len(strs)):
print(strs[index],end='')

res+='a'*3#'aaa'

s.split("")#将字符串分割成单词列表

"".join(list)#将单词列表转换为字符串，以空格分隔

f'{bulls}A{cows}B'#{}计算格式化

a=list(str(n))#int转成list
a[i-1]=str(int(a[i-1])-1)#操作字符
int("".join(a))#list转化为int

isdigit#函数判断是否数字
isalpha#判断是否字母

print"Mynameis%sandweightis%dkg!"%('Zara',21)
%s	格式化字符串
%d	格式化整数
%f	格式化浮点数字，可指定小数点后的精度

允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符
>>>hi='''hi
there'''
>>>hi#repr()
'hinthere'
>>>printhi#str()
hi
there

string.count(str,beg=0,end=len(string))
#返回str在string里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数

string.endswith(obj,beg=0,end=len(string))
#检查字符串是否以obj结束，如果beg或者end指定则检查指定的范围内是否以obj结束，如果是，返回True,否则返回False.

string.find(str,beg=0,end=len(string))
#检测str是否包含在string中，如果beg和end指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1

string.format()
#格式化字符串

string.index(str,beg=0,end=len(string))
#跟find()方法一样，只不过如果str不在string中会报一个异常.

string.join(seq)
#以string作为分隔符，将seq中所有的元素(的字符串表示)合并为一个新的字符串

string.replace(str1,str2,num=string.count(str1))
#把string中的str1替换成str2,如果num指定，则替换不超过num次.

string.split(str="",num=string.count(str))
#以str为分隔符切片string，如果num有指定值，则仅分隔num+1个子字符串

#可写函数说明
defprintinfo(name,age=35):
"打印任何传入的字符串"
print"Name:",name
print"Age",age
return
#调用printinfo函数
printinfo(age=50,name="miki")
printinfo(name="miki")


#可写函数说明
defprintinfo(arg1,*vartuple):
"打印任何传入的参数"
print"输出:"
printarg1
forvarinvartuple:
printvar
return
#调用printinfo函数
printinfo(10)
printinfo(70,60,50)

importcopy
l1=[[1,2],3]
l2=copy.copy(l1)
l3=copy.deepcopy(l1)
l2.append(4)
l2[0].append(5)
l3[0].append(6)
l1=[[1,2,5],3]
l2=[[1,2,5],3,4]
l3=[[1,2,6],3]

#可写函数说明
sum=lambdaarg1,arg2:arg1+arg2
#调用sum函数
print"相加后的值为:",sum(10,20)
print"相加后的值为:",sum(20,20)

importsupport

fromfibimportfibonacci

frommathimport*

#导入Phone包frompackage_runoob.runoob1importrunoob1frompackage_runoob.runoob2importrunoob2

runoob1()runoob2()

str=input("请输入：")
print"你输入的内容是:",str

fo=open("foo.txt","w")
print"文件名:",fo.name
print"是否已关闭:",fo.closed
print"访问模式:",fo.mode
print"末尾是否强制加空格:",fo.softspace

#打开一个文件
fo=open("foo.txt","w")
str=fo.read(10)
fo.write("www.runoob.com!nVerygoodsite!n")
#关闭打开的文件
fo.close()

importos
os.rename("test1.txt","test2.txt")
os.remove("test2.txt")

os.mkdir("test")
#将当前目录改为"/home/newdir"
os.chdir("/home/newdir")
#给出当前的目录
printos.getcwd()
#删除”/tmp/test”目录
os.rmdir("/tmp/test")

try:
正常的操作
......................
except:
发生异常，执行这块代码
......................
else:
如果没有异常执行这块代码

try:
fh=open("testfile","w")
fh.write("这是一个测试文件，用于测试异常!!")
exceptIOError:
print"Error:没有找到文件或读取文件失败"
else:
print"内容写入文件成功"
fh.close()

try-finally语句无论是否发生异常都将执行最后的代码。
try:

finally:
#退出try时总会执行
raise

try:
fh=open("testfile","w")
try:
fh.write("这是一个测试文件，用于测试异常!!")
finally:
print"关闭文件"
fh.close()
exceptIOError:
print"Error:没有找到文件或读取文件失败"

classEmployee:
'所有员工的基类'
empCount=0

def__init__(self,name,salary):
self.name=name
self.salary=salary
Employee.empCount+=1

defdisplayCount(self):
print"TotalEmployee%d"%Employee.empCount

defdisplayEmployee(self):
print"Name:",self.name,",Salary:",self.salary

"创建Employee类的第一个对象"
emp1=Employee("Zara",2000)
"创建Employee类的第二个对象"
emp2=Employee("Manni",5000)
emp1.displayEmployee()
emp2.displayEmployee()
print"TotalEmployee%d"%Employee.empCount

classA:#定义类A
.....

classB:#定义类B
.....

classC(A,B):#继承类A和B
.....

登录后复制