基础知识
基本输出流:print(“Hello python world!”)
没有结束符,对大小写敏感,注释用#开头,多行注释可以用两段"""
或者'''
将注释包含起来。
1. 标准数据类型
1.1变量
message=”Hello world!”
print(message)
1.2字符串
在python中用引号括起来的都是字符串,其中引号可以是单引号也可以是双引号。
1)使用方法修改字符串的大小写
name="Ada lovelace"
print(name.title())
print(name.upper())
print(name.lower())
上述代码输出结果如下
2)合并字符串
a="我正在"
b="python"
c=a+"学习"+b
print(c)
上述代码输出结果如下
3)使用制表符来添加空白
转义字符同C语言
删除空白用的不多吧,用的时候百度吧
4)python字符串运算符
a="Hello"
b="World"
print("a + b 输出结果:", a + b)
print("a * 2 输出结果:", a * 2)
print("a[1] 输出结果:", a[1])
print("a[1:4] 输出结果:", a[1:4])
if( "H" in a) :
print("H 在变量 a 中")
if( "M" not in a) :
print("M 不在变量 a 中")
print (r'\n') #使转义字符表达原来的意思
print (R'\n')
上述代码输出结果如下
5)字符串格式化(格式化符号同C语言)
print("我是%s,我是%d月份出生的!"%("小明",7))
上述代码输出结果如下:
1.3数字
python数字有整数,浮点数
1) 整数
2) 浮点数
3) 数字函数
4)数字类型转化
int(x):将x转换为一个整数。
float(x):将x转换到一个浮点数。
complex(x):将x转换到一个复数,实数部分为x,虚数部分为0。
complex(x,y):将x和y转换到一个复数,实数部分为x,虚数部分为y。x和y是数字表达式。
5) 使用函数str()避免类型错误
这是一个类型错误,python不知道23是int变量还是字符2和3。
使用str()函数
1.4列表
把他类比C语言中的指针数组。
在python中,用方括号([ ])括起来表示列表,用逗号来分隔其中的元素。
1)输出列表中元素
language=["php","html","css","mysql","javascript"]
print(language)
for i in range(0,5):
print(language[i])
print(language[1:3])
上述代码输出结果如下:
修改字符串大小写同样适用于列表。
2)修改添加和删除列表中的元素
- 修改列表中的元素
language=["php","html","css","mysql","javascript"]
print(language)
language[0]="python"
print(language)
上述代码运行结果如下:
- 在列表中添加元素
i)在列表末尾添加元素append()
language=["php","html","css","mysql","javascript"]
print(language)
language.append("python")
print(language)
ii)在列表中插入元素insert()
language=["php","html","css","mysql","javascript"]
print(language)
language.insert(1,"python")
print(language)
上述代码运行结果如下
第三行表示在索引1处添加了元素python。
- 从列表中删除元素
i)使用del语句永久删除元素
如果已经知道要删除的元素在列表中的位置
language=["php","html","css","mysql","javascript"]
print(language)
del language[0]
print(language)
上述代码运行结果如下:
ii)使用pop语句新建列表删除元素,依旧可以访问原表中的元素
language=["php","html","css","mysql","javascript"]
print(language)
poped_language=language.pop(3)
print(language)
print(poped_language)
pop可以删除任意位置的值不过不加数值默认为-1。
iii)我们还可以根据元素值用remove来删除
language=["php","html","css","mysql","javascript"]
print(language)
removed_language=language.remove('css')
print(language)
print(poped_language)
上述代码运行结果如下:
3)组织列表
- 使用sort()方法对列表进行永久性排序
language=["php","html","css","mysql","javascript"]
language.sort()
print(language)
language.sort(reverse=True)
print(language)
当在sort方法中加入reverse=True
时将会倒序排列
- 使用sorted()方法对列表进行临时排序
language=["php","html","css","mysql","javascript"]
print(sorted(language))
print(language)
- 倒着打印列表(与原列表顺序相反)
language=["php","html","css","mysql","javascript"]
print(language)
language.reverse()
print(language)
- 确定列表的长度
language=["php","html","css","mysql","javascript"]
len(language)
4)脚本操作符
5)嵌套列表
a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
print(x)
print(x[0])
print(x[1])
6)列表的其他函数和方法
max(list):返回列表的最大值
min(list):返回列表的最小值
list(seq):将元组转化为列表
list.count(obj):统计某个元素在列表中出现的次数
list.extend(seq):一次性在列表末尾追加多个元素
list.index(obj):从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj):将对象插入列表
list.clear():清空列表
list.copy():复制列表
1.5元组
元组看起来犹如列表,不同的是元组中的值无法修改,并且元组使用小括号,列表使用方括号。
tuple=('1','2')
for a in tuple:
print(a)
元组虽然不能修改其元素,但是能够重新定义元组
tuple=('1','2')
print("原元组为:")
for a in tuple:
print(a)
tuple=('3','4')
print("修改后元组为:")
for b in tuple:
print(b)
1.6字典(有点像结构体,但是很多不同之处)
1)基本用法如下:
dictionary={key1:value1,key2:value2}
字典由键-值组成,其中键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行。
此外,不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住。
2)访问字典中的值
alien={'color':'green','points':5}
print(alien['color'])
print(alien)
上述代码运行结果:
3)添加、修改、删除字典中的值
alien={'color':'green','points':5}
a=str(alien)#输出字典
print("字典原有键值"+a)
alien['x_position']=0
alien['y_position']=25
alien['color']='red'
del alien['points']
b=str(alien)
print("字典现在键值"+b)
1.7集合
集合(set)是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
创建格式:
parame = {value01,value02,...}
或者
set(value)
创建集合:
a=set('abcdabcd')
print(a)
b={'a','b','e','a','d','b'}
print(b)
1)集合运算:
a=set('abcdabcd')
print(a)
b={'a','b','e','a','d','b'}
print(b)
print(a-b)#集合a中包含而集合b中不包含的元素
print(a|b)#集合a和b中的所有元素
print(a&b)#集合a和b都包含的元素
print(a^b)#不同时包含于a和b中的元素
2)增加、删除集合元素
增加元素语法格式如下:
s.add(value1)
还有一个方法,也可以添加元素,且参数可以是列表,元组,字典等,语法格式如下:
s.update(value1,value2,...)
a=set('abcdabcd')
b=list(range(1,5,2))
a.add('123')
print(a)
a.update(b,[9,8],{'z','x'})
print(a)
移除元素:
语法格式如下:
将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误。
s.remove(value)
此外还有一个方法也是移除集合中的元素,且如果元素不存在,不会发生错误。格式如下所示:
s.discard(value)
我们也可以设置随机删除集合中的一个元素,语法格式如下:
s.pop()
但是在交互模式下,会固定删除第一个元素
a=set('abcdabcd')
b=a.pop()
print(b)
print(a)
3)其他操作
2.操作列表
首先先写一个注意的地方,python每条语句自动给你增加换行符,刚开始我觉得还非常方便,不需要自己打,但是发现有时需要两条语句在同一行,如果要实现不换行需要在变量末尾加上 end=""。
x="a"
y="b"
# 换行输出
print( x )
print( y )
print('---------')
# 不换行输出
print( x, end=" " )
print( y, end=" " )
print()
2.1遍历整个列表
languages=["php","html","css","mysql","javascript"]
for language in languages:
print(language)
上述代码运行结果:
python最具特色的就是使用缩进来表示代码块,不需要使用大括号 {} 。
缩进的空格数是可变的,但是同一个代码块的语句必须包含相同的缩进空格数。
例如:
languages=['php','MySql','javascript','html']
for language in languages:
print(language)
print("是我自学的\n")
print("还要自学python")
运行结果:
2.2数值列表
1)使用函数range()
for value in range(1,5):
print(value)
上述代码打印的不是1到5,而是1到4.
2)创建数字列表
如果将range()作为list的一个参数,输出将会为一个数字列表。
numbers=list(range(1,5))
print(numbers)
使用函数range还可以指定步长:
numbers=list(range(1,11,2))
print(numbers)
还可以进行乘方操作
squares=[]
for value in range(1,11):
square=value**2
squares.append(square)
print(squares)
列表解析
上面例子的几行代码等效于
squares=[value**2 for value in range(1,11)]
print(squares)
首先指定一个描述性的列表名,指定左方括号,定义一个表达式,用于生成你要储存到列表中的值。在这个示例中,表达式为value**2。接下来,编写一个for循环,用于给表达式提供值,再加上右方括号。
2.3使用列表的一部分
1)切片
list=[......]
print(list[a:b])
a是起始索引,从第a-1个开始。没有指定起始索引,Python从列表开头提取
b是终止索引,到第b个结束。没有指定终止索引,将会终止与列表尾。
还可以倒序输出
list=[......]
print(list[-a:])
将会输出列表倒数a个值。
2)遍历切片
如果要遍历列表的部分元素,可在for循环中使用切片。
players=['a','b','c','d','e']
print("Here is the first three players")
for player in players[0:3]:
print(player.title())
3)复制列表
number=list(range(1,11,2))
number_copy=number[0:3]
number_same=number
number.append(20)
number_copy.append(30)
number_same.append(40)
print(number)
print(number_copy)
print(number_same)
可以看出,当不使用切片时,number和number_same指向的是同一个列表。
3.if语句
包含 if
语句,if-else
语句,if-elif-else
语句。
and
(并)、or
(或)、in
(在…中)、not in
(不在…中)、==
(判断相等)、!=
(不相等)
if-elif-else
语句举例。
numbers=list(range(1,15,3))
for number in numbers:
if number%2==0:
print(str(number)+"is an even number!")
elif number%2==1:
print(str(number)+"is an odd number!")
else:
print(str(number)+"is a decimal!")
#上一行只是凑例子的,发现range()不能加float类型,当然可以用函数重写一个式子
and,in,not in 举例:
布尔表达式。
True
和False
。(特别注意大小写)
使用多个列表。
# use multiple list
number_a=list(range(1,15,2))
number_b=list(range(1,15,3))
b=0
for a in number_a:
if a in number_b:
print(str(a)+" is in both lists!")
else:
b+=1
print(str(b)+" values are not in list b!")
4.操作字典
1.遍历字典
遍历字典中的键-值对。
user_0={
'username':'abc',
'first':'def',
'last':'gh',}
for k,v in user_0.items():
print('\nkey:'+k)
print('value:'+v)
首先指定两个变量,k,v。然后在字典内,方法为items(),items可以返回一个键值对列表。
遍历字典中的所有键。方法为keys()。
user_0={
'username':'abc',
'first':'def',
'last':'gh',}
for keys in user_0.keys():
print(keys)
可以按顺序遍历所有键。方法为sorted()临时排序。
user_0={
'username':'abc',
'first':'def',
'last':'gh',}
for keys in sorted(user_0.keys()):
print(keys)
遍历字典中的所有值。方法为values()。
user_0={
'a':'abc',
'b':'def',
'c':'gh',
'd':'abc'}
for value in user_0.values():
print(value)
当值很多时,我们希望去掉重复值。可使用集合set()。
user_0={
'a':'abc',
'b':'def',
'c':'gh',
'd':'abc'}
for value in set(user_0.values()):
print(value)
2.嵌套
alien_0={'color':'green','point':5}
alien_1={'color':'yellow','point':10}
alien_2={'color':'red','point':15}
aliens=[alien_0,alien_1,alien_2]
for alien in aliens:
print(alien)
#创建一个空的列表
aliens=[]
#创建30个绿色的外星人
for alien_number in range(30):
new_alien = {'color':'green','point':5,'speed':'slow'}
aliens.append(new_alien)
for alien in aliens[0:5]:
print(alien)
print()
print(str(len(aliens)))
for alien in aliens[0:3]:
if alien['color']=='green':
alien['color']='yellow'
alien['speed']='medium'
alien['point']=10
for alien in aliens[0:5]:
print(alien)
在字典中储存列表
#储存所点披萨的信息
pizza={
'crust':'thick',
'toppings':['mushroom','extra cheese'],
}
#概述你所点的披萨
print("You ordered a "+pizza['crust']+"-crust pizza"+
"with the following toppings:")
for topping in pizza['toppings']:
print(topping,end=" ")
在字典中储存字典
#,有点多,编程最重要的就是标点符号
users={
'user_0':{
'first':'a',
'last':'b',
'location':'c',
},
'user_1':{
'first':'d',
'last':'e',
'location':'e',
},
}
for user,userinformation in users.items():
print("\nUser:"+user)
full_name=userinformation['first']+userinformation['last']
print("\tusername"+full_name)
print("\tlocation"+userinformation['location'])
5.用户输入和while循环
5.1input
message=input("Tell me something ,and I will tell back to you:")
print(message)
prompt="Tell me something !"
prompt+="\nAnd I will tell back to you:"
message=input(prompt)
print(message)
input输入一般被python解释为字符串,我们可以用int获取数值输入。
age=input("How old are you?")
print(int(age))
5.2while循环
python只有while循环,没有do…while。
sum=0
counter=1
while counter<=100:
sum+=counter
counter+=1
print(sum)
此外同其他语言,也有break结束循环和continue继续循环。
# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 10:
print(b)
a, b = b, a+b
上面式子最后一行从等号右边开始执行,运算完成后赋值给左边变量。等价于:
m=b
n=a+b
a=b
b=n
5.3使用while循环处理列表和字典
1)在列表之间移动元素
#首先创建一个等待验证用户列表
#和一个用于储存已验证用户的空列表
unconfirmed_users=['alice','brian','candace']
confirmed_users=['lily']
#验证每个用户、直到没有未验证用户为止
#将每个经过验证的列表都移到已验证用户列表中
while unconfirmed_users:
current_user=unconfirmed_users.pop()
print("Verifying user: "+current_user.title())
confirmed_users.append(current_user)
#显示所有以验证的用户
print("\nThe following users have been confirmed:")
for confirmed_user in confirmed_users:
print(confirmed_user.title(),end=" ")
2)删除包含特定值的所有列表元素
pets=['dog','cat','fish','rabbit','cat','fish','rabbit']
print(pets)
while 'cat' in pets:
pets.remove('cat')
print(pets)
3)使用用户输入来填充字典
responses={}
#设置一个标志,指出调查是否结束
flag=1
#提示被调查着调查内容
while flag:
name=input("\nWhat`s your name?")
response=input("Who is your favorate star?")
#将被调查内容输入到字典中去
responses[name]=response
#看看是否还有人接受调查
repeat=input("Is there anyone who want to answer?(yes/no)")
if repeat =='no':
flag=0
#输出字典
print(responses)
6.函数
6.1定义函数
一般格式如下:
def 函数名(参数列表):
函数体
def greet():
print("Hello!")
greet()
同其他语言一样,python也需要注意实参,形参的区别,也可以在定义函数的时候给参数赋默认值。
位置实参必需要有正确顺序,而关键字(即实参形参名称一样)python会自动匹配。
ps:给函数定义默认值时,等号两边不要有空格。
def function_name(parameter_0,parameter_1='defalut value')
同样对于函数调用关键字实参,也应该遵循这种约定:
function_name(value_0,parameter_1='value')
def describe_pets(name,type='dog'):
print("\nI have a ",type)
print("\twhich its name is ",name)
describe_pets(type='cat',name='Jack')
describe_pets(name='Jhon')
6.2返回值
下面是菜鸟教程的,我觉得讲的很好。
可更改(mutable)与不可更改(immutable)对象
在 python 中,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没有动,只是其内部的一部分值被修改了。 python 函数的参数传递:
不可变类型:类似 c++ 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。
可变类型:类似 c++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外部的la也会受影响
1)让实参变成可选的
def getFull_name(first,last,middle=''):
if middle:
full_name=first+" "+middle+" "+last
else:
full_name=first+" "+last
return full_name
full_name=getFull_name('jimi','hendrix')
print(full_name.title())
full_name=getFull_name('john','hooker','lee')
print(full_name.title())
以上例子middle为可选的话,必需位于形参最后加上=''
返回字典
def getFull_name(first,last):
person={'first':first,'last':last}
return person
a=getFull_name('jimi','hendrix')
print(a)
2)返回字典
函数可以返回任何类型的值,包括复杂的列表和字典等较复杂的数据结构
例如:
def build_person(first_name,last_name):
"""返回一个字典值,其中包含一个人的信息"""
person={'first name':first_name,
'last name':last_name,
}
return person
a=build_person('jimi','hendrix')
print(a)
3)集合使用函数和while循环
6.3传递列表
def greet_everyone(list):
for guest in list:
print("Hello "+guest.title()+"!")
return
list=['a','b','c']
greet_everyone(list)
1)在函数中修改列表
#首先创建一个列表,其中包含一些要打印的设计
unprinted_designs=['iphone case','robot pendant','dodecahedron']
completed_models=[]
"""模拟打印每个设计,直到没有未打印的设计为止
打印每个设计后,都将其移到列表completed_models中"""
def print_models(unprinted_designs,completed_models):
while unprinted_designs:
current_design=unprinted_designs.pop()
#模拟根据设计制作3D打印模型的过程
print("Pringting model:"+current_design)
completed_models.append(current_design)
return
def show_completed_models(completed_models):
print("\nThe following models are completed!")
for completed_model in completed_models:
print(completed_model)
return
print_models(unprinted_designs,completed_models)
show_completed_models(completed_models)
2)禁止修改列表
有时候需要将列表的值传递给函数而又不希望修改列表。
法一:使用tuple(seq)
函数将列表转化为元组。缺点:无法使用列表函数。
法二:可以像下面的方式传递列表
function_name(list_name[:])
切片表示法[:]
创建的副本。
如上面举例打印的函数希望列表unprinted_designs
的值不被删除,将调用函数的语句改为:print——models(unprinted_designs[:],completed_models
。
6.4
1)传递任意数量的实参
def make_pizza(*toppings):
'''打印顾客点的所有配料'''
print(toppings)
return
make_pizza('pepperoni')
make_pizza('mushroom','green peppers','extra cheese')
*toppings
中的星号让python创建一个名为toppings的元组,可以储存传来的值。
若是参数列表为不止有一个,则会把剩下的实参赋给*
def make_food(food,*toppings):
'''打印顾客点的所有配料'''
print(food,toppings)
return
make_food('pizza','mushroom','green peppers','extra cheese')
2)传递任意数量的关键字实参
形参列表有两个星号(*)时,参数会以字典一样的形式导入。
def build_profile(first,last,**user_info):
'''创建一个字典,其中包含我们知道的有关用户的一切信息'''
profile={}
profile['first name']=first
profile['last name']=last
for key,value in user_info.items():
profile[key]=value
return profile
user_profile=build_profile('albert','einstein',
location='princeton',
field='physics')
for keys,values in user_profile.items():
print(keys+":"+values)
ps:匿名函数不看了,和JavaScript的构造函数差不多,用的不多。
6.5将函数存储在模块中
(相当于C语言的库文件)
1)导入整个模块
import file
使用模块中的函数
file.function()
首先我们创建一个制作pizza.py
文件,里面包含函数making_pizza
def make_pizza(size,*toppings):
'''概述要制作的pizza'''
print("\nMaking a "+str(size)+
"-inch pizza with the following toppings")
for topping in toppings:
print("-"+topping)
然后新建一个making_pizza.py
文件,和pizza.py
文件在同一个目录下。
import pizza
pizza.make_pizza(16,'mushroom','green pepper','extra cheese')
导入刚才创建的文件。
2)导入特定的函数
from file import function_1,function_2,function_3...
使用导入的函数
function()
例如上例修改
from pizza import make_pizza
make_pizza(16,'mushroom','green pepper','extra cheese')
同样的结果。
3)使用as
给模块指定别名
import file as alias
可以简化许多代码,上例
import pizza as p
p.make_pizza(16,'mushroom','green pepper','extra cheese')
4)使用as
为函数创建别名
如果导入的函数和本文件中的函数重名的话,可以这样做。
from file import function as alias
例如制作pizza
from pizza import make_pizza as mp
mp(16,'mushroom','green pepper','extra cheese')
5)导入模块中的所有函数
from file import *
例如制作pizza
from pizza import *
make_pizza(16,'mushroom','green pepper','extra cheese')
6.6变量作用域(引用菜鸟教程)
Python 中,程序的变量并不是在哪个位置都可以访问的,访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种,分别是:
- L (Local) 局部作用域
- E (Enclosing) 闭包函数外的函数中
- G (Global) 全局作用域
- B (Built-in) 内置作用域(内置函数所在模块的范围) 以 L –> E –> G –>B 的规则查找,即:在局部找不到,便会去局部外的局部找(例如闭包),再找不到就会去全局找,再者去内置中找。
g_count = 0 # 全局作用域
def outer():
o_count = 1 # 闭包函数外的函数中
def inner():
i_count = 2 # 局部作用域
内置作用域是通过一个名为 builtin
的标准模块来实现的,但是这个变量名自身并没有放入内置作用域内,所以必须导入这个文件才能够使用它。在Python3.0中,可以使用以下的代码来查看到底预定义了哪些变量:
import builtins
dir(builtins)
Python 中只有模块(module),类(class)以及函数(def、lambda)才会引入新的作用域,其它的代码块(如
if/elif/else/、try/except、for/while等)是不会引入新的作用域的,也就是说这些语句内定义的变量,外部也可以访问,如下代码:
>>> if True:
... msg = 'I am from Runoob'
...
>>> msg
'I am from Runoob'
>>>
实例中 msg 变量定义在 if 语句块中,但外部还是可以访问的。
如果将 msg 定义在函数中,则它就是局部变量,外部不能访问:
>>> def test():
... msg_inner = 'I am from Runoob'
...
>>> msg_inner
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'msg_inner' is not defined
>>>
从报错的信息上看,说明了 msg_inner 未定义,无法使用,因为它是局部变量,只有在函数内可以使用。
全局变量和局部变量 定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。如下实例:
#!/usr/bin/python3
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
#返回2个参数的和."
total = arg1 + arg2 # total在这里是局部变量.
print ("函数内是局部变量 : ", total)
return total
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)
当内部作用域想修改外部作用域的变量时,就要用到global和nonlocal关键字了。
以下实例修改全局变量 num:
#!/usr/bin/python3
num = 1
def fun1():
global num # 需要使用 global 关键字声明
print(num)
num = 123
print(num)
fun1()
print(num)
如果要修改嵌套作用域(enclosing 作用域,外层非全局作用域)中的变量则需要 nonlocal 关键字了,如下实例:
#!/usr/bin/python3
def outer():
num = 10
def inner():
nonlocal num # nonlocal关键字声明
num = 100
print(num)
inner()
print(num)
outer()
6.7函数内定义函数
在6.6中引用菜鸟教程中示例中,发现函数内可以定义函数,但是从网上没有搜到很好的教程,我买的书上也没讲,这里留疑。
7.类
7.1创建和使用类
1)创建类
class Dog():
"""Dog类"""
instruction="This is a dog."
def __init__(self,name,age):
self.name=name
self.age=age
def sit(self):
"""对坐下命令的模拟"""
print(self.name.title()+" is now sitting.")
def roll_over(self):
"""对打滚命令的模拟"""
print(self.name.title()+" rolled over")
在Python中,首字母大写的名称指的是类。
类中的函数称为方法,而方法__init__()
是一个特殊的方法,当你根据Dog类创建新实例时,Python都会运行它。
我们上述方法__init__()
定义中包含三个形参,形参self是必不可少的,还必须位于其他形参前面,Python在调用方法__init__()
时都会自动传递实参self,他是一个指向实例本身的引用,我们在调用类时,不需要传递它,只需要给最后两个形参赋值即可。
(ps:self不是关键字,换成其他也可以,但是按照惯例我么使用self)
2)使用类
import Dog
my_dog=Dog.Dog('ABC',5)
print(my_dog.instruction)
print("My dog`s name is "+my_dog.name.title())
print("My dog is "+str(my_dog.age)+" years old.")
my_dog.sit()
my_dog.roll_over()
在上面我们创建了类Dog,现在我们把类导入,导入方法和函数一样
同函数,你可以反复调用此类,创建不同的实例。
7.2创建类和实例
1)给属性指定默认值
class Car():
"""模拟汽车"""
def __init__(self,make,model,year):
"""初始化汽车信息"""
self.make=make
self.year=year
self.model=model
self.odometer=0
def get_desc_name(self):
"""描述汽车信息"""
desc_name=str(self.year)+" "+self.make+" "+self.model
return desc_name.title()
def read_odometer(self):
"""打印汽车里程消息"""
print("This car has "+str(self.odometer)+" miles on it.")
my_car=Car('audi','a4',2016)
print(my_car.get_desc_name())
my_car.read_odometer()
2)修改属性
法一:直接修改属性的值
import car
my_car=car.Car('audi','a4',2016)
print(my_car.get_desc_name())
my_car.read_odometer()
my_car.odometer=23
my_car.read_odometer()
法二:通过方法修改属性的值
在类内定义另外的方法
class Car():
--snip--
def update_odometer(self,mileage):
"""更新里程"""
if mileage>=self.odometer:
self.odometer=mileage
else:
print("You can`t roll back an odometer!")
调用
import car
my_car=car.Car('audi','a4',2016)
print(my_car.get_desc_name())
my_car.read_odometer()
my_car.update_odometer(46)
my_car.read_odometer()
法三、定义递增方法
class Car:
--snip--
def incr(self,miles):
self.odometer+=miles
调用:
import car
my_car=car.Car('audi','a4',2016)
print(my_car.get_desc_name())
my_car.read_odometer()
my_car.update_odometer(46)
my_car.incr(16)
my_car.read_odometer()
7.3继承
1)继承
前面我们创建了汽车的类,基于此我们创建一个电动汽车的类。
import car
class ElectriCar(car.Car):
"""电动汽车的独特之处"""
def __init__(self,make,model,year):
"""初始化父类的属性"""
super().__init__(make,model,year)
my_tesla=ElectriCar('tesla','model s',2016)
print(my_tesla.get_desc_name())
创建子类时,父类必需在子类前面(同文件或者导入都可以)。
子类中__init__
接受创建Car实例所需要的信息。
super()
是一个特殊函数,帮助父类和子类关联起来,让子类拥有父类所有属性。
2)重写父类
有时我们希望继承父类,但不是继承所有。
加入父类Car中含有一个fill_gas_tank()的方法,它对电动汽车来说毫无意义,因此我们可以在子类中重写这个方法,如果我们调用子类中的这个方法,父类的方法将会被忽略。
3)将实例用作属性
class Car():
--snip--
class Battery():
"""模拟电动汽车电瓶"""
def __init__(self,battery_size=70):
"""初始化电瓶的属性"""
self.battery_size=battery_size
def desc_battery(self):
"""打印一条描述电瓶的消息"""
print("This car has a "+str(self.battery_size)+"-kWh battery.")
class ElectriCar(Car):
"""电动汽车的独特之处"""
def __init__(self,make,model,year):
"""初始化父类的属性"""
super().__init__(make,model,year)
self.battery=Battery()
my_tesla=ElectriCar('tesla','model s',2016)
print(my_tesla.get_desc_name())
my_tesla.battery.desc_battery()
"""调用类的类的方法"""
我们新建了一个Battery类,他没有继承任何新类,我们在创建ElectriCar时调用了它。,这看似做了很多额外工作,但现在我们可以多详细的描述电瓶都可以,不会使得ElectriCar变得混乱不堪。
7.4导入类和函数类似不过没有别名。
7.5类的私有方法
__private_method:两个下划线开头,声明该方法为私有方法,只能在类的内部调用 ,不能在类的外部调用。self.__private_methods。
7.6类的专有方法
7.7运算符重载
Python同样支持运算符重载,我们可以对类的专有方法进行重载,实例如下:
#!/usr/bin/python3
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)
8.文件和异常
ps:前面我以为很少用的知识发现在这有用。
方法rstrip()
:删除字符串后端的空白。
lstrip()
:删除字符串前端空白。
strip()
:删除字符串两端空白。
基本语法:(这一大块只是记录,实际不会用这么多,用于查阅。)
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
file: 必需,文件路径(相对或者绝对路径)。
mode: 可选,文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener:
mode 参数有:
默认为文本模式,如果要以二进制模式打开,加上 b 。
常用方式:
open(file, mode='r')
8.1从文件中读取数据
with open('pi.txt') as pi:
contents=pi.read()
print(contents)
详解:
关键字with
在不再需要访问文件后将其关闭,我们使用了open()
方法,但是没有使用close()
;不建议使用open()+close()
方式来处理文件,如果程序出现bug导致close()
语句未执行,文件不会关闭,会丢失数据。使用with
,Python会适时将其关闭。
据书上说read()方法到达文件末尾会返回一个空字符串,要删除空字符串,使用方法rstrip()
将空白删除。即将最后一句改为print(contents.rstrip())
文件路径:分为相对路径和绝对路径
同HTML一样尽量使用相对路径,少使用绝对路径。(反斜杠(\))
现在我们不再将txt文本和pi.py放在同一个级别下。将txt文本放在pi2文件夹下,以pi.py为相对路径
那么读取时pi2\pi.txt
现在我们逐行读取:
file='pi2\pi.txt'
with open(file) as pi:
for line in pi:
print(line.rstrip())
创建一个包含文件各行内容的列表。
file='pi2\pi.txt'
with open(file) as pi:
lines=pi.readlines()
for line in lines:
print(line.rstrip())
方法readlines()
将从文件中读取每一行,并将其存储在一个列表中。该列表被存储在变量lines
中;在with
代码块外,我们依旧可以使用这个变量,那么你就可以在with代码块外使用这些内容。
8.2写入文件
file='text.txt'
with open(file,'w') as text:
text.write("This is a text!\n")
模式w将会以写入模式操作文件(如果文件不存在,将会创建文件,如果文件存在,将会清空文件内容,要追加方式,用a)。
方法write()并不会自动在每行自动添加换行符,需要我们自己加入。
python读写文件都是字符串,如果要写入数字,先将数字用str()转化为字符串,如果要操作读取的数字,那么用int()或者float()转化为整形或者浮点型操作。
8.3异常
使用try-except
代码块
try:
print(5/0)
except ZeroDivisionError: #注意缩进
print("You can`t divide by zero!")
上述代码中,如果try代码块中的语句没有错误,那么将忽略except语句,否则核对错误类型是否为except后面的错误类型,如果是就执行except代码块中的语句。
一个except子句可以同时处理多个异常,这些异常将被放在一个括号里成为一个元组,例如:
except(RuntimeError, TypeError, NameError):
pass
pass语句会让except什么也不做
else代码块(放置依赖于try代码块成功执行的代码)
print("Give me two numbers,and I will divide them!")
print("Enter 'q' to quit.")
while True:
first=input("\nFirst number:")
if first=='q':
break
second=input("Second number:")
if second=='q':
break
try:
answer=int(first)/int(second)
except ZeroDivisionError:
print("You can`t divide by 0!")
except ValueError:
print("You must print number!")
else:
print(answer)
8.4存储数据
1)使用json.dump
()和json.load()
(感觉是做开发必不可少的)
json.dump()
用来存储数据,json.load()
用来读入内存中的程序。
import json
numbers=[2,3,5,7,11,13]
file='number.json'
with open(file,'w') as f_obj:
json.dump(numbers,f_obj)
with open(file) as read:
number_2=json.load(read)
print(number_2)
先导入模块json
然后以写的方式打开文件,使用json.dump()
将数字列表存储到文件number.json中。
然后我们以读的方式打开这个文件,然后使用json.load()
读取存储的数据。
综合运用一下
import json
def get_stored_username():
"""如果存储了用户名,就获取它"""
file='user_name.json'
try:
with open(file) as read:
username=json.load(read)
except FileNotFoundError:
return None
else:
return username
def get_new_username():
"""获取新的用户名"""
username=input("What`s your name?")
file='user_name.json'
with open(file,'w') as write:
json.dump(username,write)
return username
def greet_user():
"""问候用户"""
username=get_stored_username()
if username:
print("Welcome back,"+username+"!")
else:
username=get_new_username()
print("I`ll remember you when you back,"+username+"!")
greet_user()
两次运行结果: