标签：指定元素 ssi 数值 长度 sub nio 理解 etl wing
|
Python基础知识 汇总 |
|
Python入门知识 |
|
Never say dead，just from now —— 一个土豆 |
|
|
|
|
|
|
目录
第一章----简单了解数据类型
1.1 变量
1.2 字符串
1.3 列表
1.4 字典
1.5 元组
1.6 整形
1.7 布尔值
第二章---------基本语句类型
1.1 if语句
1.2 for语句
1.3 while语句
1.4 简单的语句补充
第三章-------关于数据类型常用的功能
1.1 列表
1.2 整形
1.3 字符串
1.4 元组
1.5 字典
1.6 布尔值
1.7 集合
1.8 补充 百分号格式化 format 格式化
第四章---------------更高级的层次
1.1 函数
1.2 局部和全局变量
1.3 类（使用和理解）
第一章
1.1，变量（含义、格式及功能）
message="hello python word "其中message就是变量名，而后面的就是有实际意义的变量。
print(message) “print语句： 输出程序结果”
message="hello python crash course world"
print(message)
#变量的命名和使用#
1.变量只能是字母，数字和下划线。注意字母，下划线可以打头 数字不行
2.变量名不能含有空格，但是可以用下划线来分开。
3.不能将python中的函数名用来做变量名。
4.保证变量的变量名和print输出的值要一致 ，不然就会出错 在查找的时候相当困难，**特此提醒 关于大小写字母 容易将其与1,和0混淆**
1.2字符串 str（含义、格式及功能）
含义：用双引号括起来的就是字符串
name="kongweixin"
print(name.upper())*********#upper(),为全部大写
print(name.title())***********#title()首字母大写
print(name.lower())**********#lower(),为全部小写
#功能一 合并（拼接）字符串#
例:
frist_time="kwx"
last_time="yf"
full_time=frist_time+" "+last_time+" we are family"
print(full_time)
组合起来利用
frist_time="kwx"
last_time="yf"
full_time=frist_time+" "+last_time
print("hello, "+full_time.title()+" forever")
###补充###： 换行符，制表符来添加空白(\n :换行符)
print("language:\npython\njava\nc++\nc#")
#功能二 删除空白（尾部空白：rstrip()，头部空白：lstirp(),两头空白：stirp()）
例：
frist_time="kwx"
last_time="yf"
full_time=frist_time+" "+last_time+" we are family "
print(full_time.strip().title())
###补充###
数字与str（）引用
例：
age=21
name=”kong weixin ”
message=”hello”+str(name)+”,”+str(age)+”rd birthday”
print(message.title)
1.3列表list （含义、格式及功能）
含义：列表就是用‘[元素,元素 , 元素, 元素]’的格式组成。**编程中从0开始数**，
例：1)
bicycle=["trek","cannondale","redline","specailized","hero","queen"]
print(bicycle)
2)
bicycle=["trek","cannondale","redline","specailized","hero","queen"]
message="my frist bicycle was a "+bicycle[0].title()+‘.‘
print(message)
#功能一，列表中添加元素：append（“添加内容”）、例式bicycles.append(‘kongmei‘)
bicycles=["trek","cannondale","redline","specailized","hero","queen"]
bicycles.append(‘kongmei‘)#无需变量名
print(bicycles)
##功能二，列表中插入元素：insert(位置,"元素名")
motorcycles=["honda","yamaha","suzuki"]
motorcycles.insert(1,"awm")#、insert(1,"awm")就是在1处添加awm
print(motorcycles)
1.4字典 dic （含义及、格式及功能）
含义：字典是由键值对和大括号组成，键值对：{“key(键)”:”value（值）或简写k，v”}
例：
alien_0={‘color‘:‘green‘,‘points‘:5}
print(alien_0[‘color‘])
print(alien_0[‘points‘])
#命名外星人
alien_0={‘coior‘:‘green‘,‘points‘:‘5‘}
new_points=alien_0[‘points‘]
print("you just earned"+str(new_points)+"points!")
#功能一，添加键值对
alien_0={‘color‘:‘green‘,‘points‘:‘5‘}
alien_0[‘x_position‘]=0 #此处添加的是游戏内外星人的坐标
alien_0[‘y_position‘]=25#只需知道字典名[‘键‘]=值即可
print(alien_0)
#功能二，修改字典中的值
alien_0={‘color‘:‘green‘}
print("the alien is" +alien_0[‘color‘]+".")
*只需要添加alien_0[‘color‘]=“；；；；；；；”内部随便填
alien_0[‘color‘]=‘yellow‘
print("the alien_0 is now " + alien_0[‘color‘]+".")
#功能三，删除键—值对
alien_0={‘color‘:"green",‘points‘:5}
print(alien_0)
del alien_0[‘points‘]
print(alien_0)#（del 删除作用和列表都可以这么用）
#功能四，由类似对象组成字典
favorite_languages={
‘jen‘:‘python‘,
‘sarah‘:"c",
‘edward‘:‘ruby‘,
‘phil‘:‘python‘,#这里最好在写完后再加一个’ , ’**规定如此|不加也不会报错**
}
print("sarah`s favorite language is "+
favorite_languages[‘sarah‘].title()+"." )
#功能五，遍历字典
user_0={
‘username‘:‘efermi‘,
‘frist‘:"enrico",
‘last‘:‘fermi‘,
}
for k,v in user_0.items(): #方法items()*如果不用k，v就默认为key*
print("\nkey:"+ k)
print("value:"+ v)
#功能六，按顺序遍历字典的所有键
favorite_languages={
‘jen‘:‘python‘,
‘sarah‘:"c",
‘edward‘:‘ruby‘,
‘phil‘:‘python‘,
}
for name（就如key） in sorted( favorite_languages.keys()):
print(name.title()+",thank you for taking the poll.")
1.5元组tuple(含义、格式及功能)
含义：如列表一样，不同的就是括号和性质的变动。列表可以变动内部的值而元组不可更改，就像游戏固定的数据一样（但还是有正常的修改的途径）
#正常的改变途径（修改也是从新定义不能在原来的元组上修改）
元素=(相关信息)
print("original 元素")
for dimension in dimensions:
print(元素)此时可以输出，并且此时为初始状态
元素=(更新过后的相关信息)
print("modified 元素")
for dimension in dimensions:
print(新元素)
1.6整形 int（数字）（含义、格式及功能）
含义：就是阿拉伯数字
格式：0123456789#编程中数字一般从0开始*其中进制数的利用*
1.7布尔值 bool（含义、格式及功能）
含义：在输出的时候判断True或Flase。
格式：True或False
布尔值是判断真假命题的只要记住以下假命题其余的基本上都是真命题、
假命题有：None 空字符串“" ””空列表[] 空字典{} 0 都是 Flase
例：转换时bool（）
a=11111
v=bool(0)
print(v)
*****补充===》关于迭代对象的解释：迭代就是重复反馈过程的活动，，目的就是通常是为了接近并达到目的或结果
一，使用iter内置函数可以获取迭代器的对象，如果对象实现了能返回迭代器的
_iter的方法，则就是迭代对象
二，序列都可以迭代
三，实现了_getitem_方法，而参数是从零考试索引的，那么该对象为迭代对象
第二章
1.1 if语句（含义、格式及结构）
含义：conj（表条件）根据条件进行判断核心都是一个值为True或Flase的表达式
格式：cars=[‘audi‘,‘bmw‘,‘subaru‘,‘toyota‘]
for car in cars:
if car ==‘bmw‘: #此处就是if语句的格式if 元素==条件：|*后面的冒号务必要注意*|
print(car.upper())
elif car==”audi”:
print(car.upper())
else 内部条件 : #else是或者的意思如果不满足上面的if条件就会运行else。
print(car.title())
#一般的 if结构
第一种：if-----else结构：只能进行一个条件的判断
cars=[‘audi‘,‘bmw‘,‘subaru‘,‘toyota‘]
for car in cars:
if car ==‘bmw‘:
pass： #如果不想输出
else:
print(car.title())
第二种：if-elif-else结构（其中elif可多次使用条件判断这样就可以）
age=12
if age <4:
print("YOU ADMISSION COST IS $0 .")
elif age <18 or age>30: #如果多加几个条件就可以用or进行条件的追加
print("YOU ADMISSION COST IS $5. ")
else :
print ("YOU ADMISSION COST IS $10.")
第三种：省略else模块；并没有要求if后必须跟else，有些情况有重要作用必须要用。
age=12
if age <4:
price=0
elif age<18:
price=5
elif age>=65:
price=10
print("you admissin is$ "+str(price)+".")
#####
#####前两种只能输出通过测试的一个，所以筛选的时候可用
#####
第四种：测试多个条件（这里输出的结果不是一个 与if—elif 不同）
requested_toppings = [‘mushrooms‘,‘extra cheese‘]
if ‘mushrooms‘ in requested_toppings:
print("Adding mushrooms")
if ‘pepperoni‘ in requested_toppings:
print("Adding pepperoni")
if ‘extra cheese‘ in requested_toppings:
print("Adding ‘extra cheese")
print("\nFinished making your pizza!")
1.2 for语句（含义、格式及结构）
含义：for就是一种循环
格式：magicians=["honda","yamaha","suzuki"]
for magician in magicians:
print(magician)
*注意事项：循环过后执行的操作:注意缩进，看清不同字段的表述，忘记缩进的额外代码*
magicians=["honda","yamaha","suzuki","alice","david","carolina","kong weixin"]
for magician in magicians:
print(magician.title()+",that was a great trick !")
print("I can’wait to see you next trick ,"+magician.title ()+".\n")
print("thank you , everyone .that was a great magic show!")
#利用for语句创建数字列表（我有三种方法这里要用到range（）、函数list）
for value in range(1,5):
print(value)
#range()创建数字列表，list()函数
#方法一
numbers=list(range(1,6))
print(numbers)
#方法二
squares=[]
for value in range (1,11):
square=value**2
squares.append(square)
print(squares)
#方法三
numbers=list(range(2,11,2))#list(range(第一个数,最后一个数,间隔)
print(numbers)
1.3 while语句(含义、格式及结构)
含义：while循环不断地运行，直到指定的条件不满足为止。而for循环用于针对集合中的每个元素的代码块
格式：a=[]
current_number = 1
while current_number <= 5：# while current_number <= 5：
# print(current_number)
a.append(current_numb er)
current_number+=1
print(a)
while的结构:
实例一,关于让用户选择时退出
prompt = ("Tell me something , and I will repeat it back you: ")
prompt += "\n Enter ‘quit‘ to end the program"
#多行字符串的创建.第一行将信息的前半部分存储变量中.第二行进行运算符+=在存储在prompt中的字符串末尾附加一个字符串就可以
message=""
while message !=‘quit‘:
message =input(prompt)# input() 暂停运行让用户输入文本
If message !=‘quit‘:
print(message)
实例二:使用标志
所为标志是指当有许多条件满足时才能运行程序的时候, 就可以确定一个变量（被称为标志）.用于判断整个系统是否处于活动)运行时看布尔值就可以了 true\false
prompt = ("Tell me something , and I will repeat it back you: ")
prompt += "\n Enter ‘quit‘ to end the program"
active=True
while active :
message=input(prompt)
if message==‘quit‘:
active=False
else:
print(message)
实例三，while中必须知道的两个 break continue使用break ===退出循环（直接结束），使用continue ===跳过当前值重新循环
a=[]
current_number = 0
prompt = ("Please enter the name of a city you have visited : ")
prompt += "\n (Enter ‘beijin‘ when you are finished.)\n>>>"
while True:
City = input(prompt)
if City == "beijin":
print(‘you have gone this city‘)
break#直接结束
else:
print("I‘ d love to go to "+ City.title() + "!")
break
*******补充******
在while循环中尽量避免无限循环，这样可能会使程序崩掉，而且会消耗储存空间。
实例四：使用while循环处理列表和字典；
一．在列表之间移动元素
首先，创建一个待验证的用户列表，和一个已验证的用户列表。
unconfirmed_users=[‘cccccccc‘,‘lllllll‘,‘kkkk‘,‘jjjjjj‘,‘hhhh‘]
confirmed_users=[]
while unconfirmed_users:
current_users=unconfirmed_users.pop()
print("verifying user:"+current_users.title())
confirmed_users.append(current_users)
print("\nThe following users have been confirmed:")
for confirmed_users in confirmed_users:
print(confirmed_users)
***删除包含特定值的所有列表元素(@@@@@@@@@@未解决 浅拷贝和深拷贝)
pets = [‘dog‘, ‘cat‘, ‘dog‘, ‘glodfish‘, ‘cat‘, ‘rabbit‘, ‘cat‘]
print(pets)
for i in pets:
if i == ‘cat‘:
pets.remove(‘cat‘)
print(pets)
pets = [‘dog‘, ‘cat‘, ‘dog‘, ‘glodfish‘, ‘cat‘, ‘rabbit‘, ‘cat‘]
print(pets)
while ‘cat‘ in pets:
pets.remove(‘cat‘)
print(pets)
关于深拷贝和浅拷贝
import copy
a = list(range(0,30))
b = copy.deepcopy(a)#深拷贝
for i in a:
if i % 4 != 0:
b.remove(i)
print(b)
实例五 使用用户输入来填充字典
responses = {}
polling_active = True#标志:代表程序可以顺利进行
while polling_active:
name = input(‘ what is you name?‘)
response = input("which mountain would you like to climb someday?")
responses[name] = response#将元素添加给字典
repeat = input("would you like to let another person respond?(yes/no)")
if repeat == ‘no‘:
polling_active = False
print("\n----poll results---")
for name, response in responses.items():
print(name + "would you like to climb " + response + ".")
print(responses)
***********以下是个人收集补充的，*************
在python中语句分为 循环 、条件、 和无条件都是控制流程
一，print语句
在python2中是语句，在python3中是函数 其主要功能还是打印
二，赋值语句
*例如 a=3 这种就是赋值语句 而有一个十分值得注意的地方就是如果a=2
b=9 如果让他们的置换过来 一般的语言就会用
temp=a
a=b
b=temp
而在python中就直接可以ab=ba直接转换
*而且还可以链式赋值如果m=n=”asdfghgjl”/print(m,n) 就会出现两个相同的值而且id也一样 所以链式语句可以等效赋值 只要记住编程中= 不是等于就可以了**关于增量赋值就是 += | - = | *= | /= |%= |**
三，与 if有关的简单语句=========三元操作符
>>> name="111111"if "3222222"else"23333333"
>>> name
‘111111‘
>>> name="111111"if ""else"23333333"
>>> name
‘23333333‘
>>> name="111111"if "3222222"else""
>>> name
‘111111‘
总结：就是A=Y if X else Z
如果X为真，那么就执行A=Y
如果X 为假，那么就执行A=Z
实例如下：
>>> a="python"if "x>y"else"pygame"#在一般，输出的是数据类型
>>> x=2
>>> y=8
>>> a
‘python‘
>>> a="python"if "x>y"else"vdaklhv"
>>> a
‘python‘
>>> a="python"if x>y else"pygame"
>>> a
‘pygame‘
>>> b="python"if x<y else"pygame"
>>> b
‘python‘
>>> b=[0125,211]if x<y else"pygame"而这种就不行应为0为假 在布尔值的时候说过所以别0 开头
SyntaxError: unexpected indent
1.1列表 list关于list的功能
——索引和切片——
索引实例 li=[‘2‘,‘3‘,‘4‘,‘5‘,‘6‘] print(li[3])
切片实例 li=[‘0‘,‘1‘,‘2‘,‘3‘,‘1‘,‘2‘] print(li[3:-1]) #其中-1是指从右开始
可添加可修改(索引或切片)
#----索引
li=[‘2‘,‘3‘,‘4‘,‘5‘,‘6‘]
li[2]=20#
print(li)
#----切片
li=[‘2‘,‘3‘,‘4‘,‘5‘,‘6‘]
li[1:3]=[120,90]#
print(li)
删除（索引或切片）
#----索引
li=[‘2‘,‘3‘,‘4‘,‘5‘,‘6‘]
del(li[0])#
print(li)
#----切片
li=[‘2‘,‘3‘,‘4‘,‘5‘,‘6‘]
del(li[0])#
print(li)
——转换——
—字符串转换列表
s="weueiqwgvfuqewvgfuewqogfu"
v=list(s)#
print(v)
——提取——
—取列表中的列表
li=[‘2‘,‘3‘,[‘7‘,‘8‘,‘9‘,],‘4‘,‘5‘,‘6‘,"alex"]
li[2][1]=120#
print(li)
—列表中有数字和字母
li=[‘xnxnxnx‘,‘lllmlmlmlm‘,11,22,33,44,55,]
s=""
for i in li:
s=s+str(i)
print(s)[i]
—只有字符串的时候用join进行提出
li=[‘xnxnxnx‘,‘lllmlmlmlm‘]
v=‘‘.join(li)
print(v)
—list.append（）添加
bicycles=["trek","cannondale","redline","specailized","hero","queen"]
bicycles.append(‘monkey‘)
print(bicycles)
—list.insert()插入 指定位置进行插入
li=[‘xnxnxnx‘,‘lllmlmlmlm‘]
li.insert(0,99)
print(li)
—list.pop()默认从右边删除并提取pop(内部只能写一位元素的位置) 例：pop(1)
li=[‘xnxnxnx‘,‘lllmlmlmlm‘]
v=li.pop(1)#print(li)
print(v)
—list.remove()删除指定的值,左边优先
li=[‘xnxnxnx‘,‘lllmlmlmlm‘,1232132315,‘jscNHCUGCUvgc‘‘xnxnxnx‘]
li.remove(‘xnxnxnx‘)
print(li)
—list.sort()排序，有小到大排序
li=[11,22,33,44,55,66,77,88,99]
li.sort()
print(li)
—创建数值列表
for value in range(1,5):
print(value)
#range()创建数字列表，list()函数
#方法一
numbers=list(range(1,6))
print(numbers)
#方法二
squares=[]
for value in range (1,11):
square=value**2
squares.append(square)
print(squares)
#方法三
numbers=list(range(2,11,2))#list(range(第一个数,最后一个数,间隔)
print(numbers)
—*补充*list基本操作
len（list）测量list的长度
>>> li=[1,2,3.4,"chsjqb"]
>>> print(li)
[1, 2, 3.4, ‘chsjqb‘]
>>> a=len(li)
>>> print(a)
4
*连接、重复、in 和 max min（最大值 最小值）
>>> li=[1,2,3.4,"chsjqb"]
>>> ji=[456,789,101112]
>>> li + ji #连接
[1, 2, 3.4, ‘chsjqb‘, 456, 789, 101112]
>>> ji*4 #重复
[456, 789, 101112, 456, 789, 101112, 456, 789, 101112, 456, 789, 101112]
>>> li=[1,2,3.4,"chsjqb"]
>>> 1 in li # in
True #回复的是布尔值
>>> 30 in li
False
>>> li=[11,22,33,44,55,66,77,88,99]
>>> max(li)
99
—list.extend() 与append功能相近都是追加信息或者说是合并（可迭代对象）
* 不同就是append是整体追加而extend是转换为个体化在追加*
>>> ista
[2, 3]
>>> istb
[2, 4]
>>> ista.extend(istb)#不管是list还是str都按单位进行转换为list在追加
>>> ista #list.extend(len(L)等于list.extend(len(L) L为待并入的list
[2, 3, 2, 4]
>>> ista
[2, 3]
>>> istb
[2, 4, ‘hfsjgdfiy‘, ‘wjvui‘]
>>> ista.extend(istb)
>>> ista
[2, 3, 2, 4, ‘hfsjgdfiy‘, ‘wjvui‘]
>>> ista.extend("fnjeqibuoqebvuoieqgp")#加的是字符串也会转换为函数
>>> ista
[2, 3, ‘f‘, ‘n‘, ‘j‘, ‘e‘, ‘q‘, ‘i‘, ‘b‘, ‘u‘, ‘o‘, ‘q‘, ‘e‘, ‘b‘, ‘v‘, ‘u‘, ‘o‘, ‘i‘, ‘e‘, ‘q‘, ‘g‘, ‘p‘]
—list.count() 与len()功能相同就是list的长度或者说数数list有几个元素
>>> a=[1,1,1,2,2,2,3,3,3,3]
>>> a.count(2)
>>>3
—list.index(x) x 是list中的一个元素，这样就能够确定元素在list的位置
其实index就是索引
>>> ista
[2, 3]
>>> ista.extend("asdf")
>>> ista
[2, 3, ‘a‘, ‘s‘, ‘d‘, ‘f‘]
>>> ista.index(‘s‘)
3
>>> ista.index(‘d‘)
4
—list.reverse() 就是把列表的元素顺序反过来**注意**reverse只是原地反过来。
而不是生成新列表，所以没有返回值 如果想有返回值就要用reversed。
>>> a=[1,2,3,4,5,6]
>>> a.reverse()# 自己总结方法a[::-1] 也可以达到效果
>>> a
[6, 5, 4, 3, 2, 1]
*******************总结********************
在list中常用的有：
’append’ ‘count’ ‘extend ‘ ‘index ‘ ‘insert’ ‘ pop’ ‘ remove’ ‘ reverse’ ‘sort’
1.2 整形 int 关于整形的功能
一 -int 字符串换成数字
a = ‘11232‘
b = int(a)
print(b)
—进制数进行提取转换成数字
num = "0011"
v = int (num,base=16)
print(v)
—bit_length()当数字是二进制时，至少用n位表示
age=10
r=age.bit_length()
print(r)
1.3 字符串 str关于字符串的功能
*补充：字符串是由零个和多个字符组成的有限串行。一般记为s=a[1]a[2]a[3]…..a[n]*
-—转义符 功能就是转变符号的含义
>>> ‘what\‘s you name?‘
"what‘s you name?"
—拼接问题 如数据类型不同就可以由以下方法
—拼接问题 如数据类型不同就可以由以下方法
>>> a=1989
>>> b="free"
>>> print(b+a)
Traceback (most recent call last):
File "<pyshell#29>", line 1, in <module>
print(b+a)
TypeError: must be str, not int
>>> print(b+ str(a))
free1989
>>> print(b+`a`)
SyntaxError: invalid syntax
>>> print(b+repr(a))
free1989
——总结 转义符总结
\ (在行尾时)续行符 \ 反斜杠符号 \’ 单引号 \” 双引号
\a 响铃 \b 退格 \e 转义 \000 空 \n 换行符 \v 纵向制表符
\t 横向制表符 \r 回车 \f 换页 \oyy 八进制数yy代表的字符串例\o12表示换行
\xyy十六进制
—索引和切片
>>> istb
‘hfsjgdfiy‘
>>> istb[0]
‘h‘
>>> b=istb[:]
>>> print(b)
hfsjgdfiy
>>> c=istb[3;10] #注意 中间是 [ : ]
SyntaxError: invalid syntax
>>> c=istb[3:10]
>>> print(c)
Jgdfiy
**这里 len() in max min 就省略 上面有 自己动手试试 。因为字符串 也是个序列**
—str.split（）作用就是根据分割符进行分割
>>> a="I love python"
>>> a.split(" ")
[‘I‘, ‘love‘, ‘python‘]
—str.strip()去除空格 strip（）去除左右的空格 lstrip（）左侧rstrip（）右侧
>>> a="I love python"
>>> a.split(" ")
[‘I‘, ‘love‘, ‘python‘]
>>> a=" I love python "
>>> a.strip ()
‘I love python‘
>>> a.lstrip()
‘I love python ‘
>>> a.rstrip()
‘ I love python‘
— Str大小写转化 upper 大写所有 lower小写所有 capitalize 首字母大写
isupper 是否是大写 islower是否是小写 istitle 是否是标题形式（首字母大写）
>>> a=" I love python "
>>> a.upper()
‘ I LOVE PYTHON ‘
>>> a.lower()
‘ i love python ‘
>>> a.capitalize()
‘ i love python ‘
>>> a.isupper ()
False
>>> a.islower()
False
>>> a.title ()
‘ I Love Python ‘
>>> a.capitalize ()
‘ i love python ‘
>>> a.istitle()
False
— “ ”. Join()拼接字符串 ” ”里面加一些想连接的东西主要用于数量特别大的时候，
因为都知道+也可以有相同的功能但比较麻烦
>>> a="www.abcd.com"
>>> c=a.split(".")
>>> print(c)
[‘www‘, ‘abcd‘, ‘com‘]
>>> d="*".join (c)
>>> print(d)
www*abcd*com
— Str.find(“ ”,x,y) ” ”内放所找的元素与index（）差不多 不过 index容易报错
test="alexalex"
v=test.find(‘ex‘,5,8)
print(v)
— Str.format() 就是格式化代替{}中的形参
— Str.format() 就是格式化代替{}中的形参
test=‘i am {name},age={a}‘
#print(test)
v=test.format(name="alex",a="19")
print(v)
#也可以按照顺序来但是是从零开始的
test = ‘i am {0},age={1}‘
#print(test)
v = test.format("alex",19)
print(v)
#格式化，传入的值({‘name‘:"alex",‘a‘:19})
test = ‘i am {name},age={a}‘
v = test.format_map({‘name‘:"alex",‘a‘:19})
print(v)
—ljust()填充 ljust()|rjust()左右填充 ，例：ljust(|个数，“添加的字符”)ljust(20,"#")， 中间用center（）填充，
>>> e=d.ljust(20,"&") #左右填充是以左（右）为基准而不是填充左（右）边
>>> print(e)
www*abcd*com&&&&&&&&
>>> f=d.rjust(20,"#")
>>> print(f)
########www*abcd*com
>>> g=d.center (20,"%")
>>> print(g)
%%%%www*abcd*com%%%%
— Str。Maketrans(a,b) 其中a是需转换 而b是转换目标
>>> a="aeiou"
>>> b="12345"
>>> c=str.maketrans (a,b)
>>> print(c)
{97: 49, 101: 50, 105: 51, 111: 52, 117: 53}
— Str.Replce(old,new,max ) 用新替换旧的 max是次数
a="www.asdf.com"
print("网站：",a)
print("网站：",a.replace(‘asdf.com‘,‘fghj.cc‘))
str="this is string example....wow!"
print(str.replace(‘is‘,‘was‘,3))
网站： www.asdf.com
网站： www.fghj.cc
thwas was string example....wow!
—****判断类型输出的是布尔值****
#isalpha()是否全是字母 、isdigit()是否全是数字|isdecimal()也可以用于二进制数或小数，/isnumeric（）|
#islower()是否是小写， isprintable（）存在不显示的符号例如\n\t ， ispace()是否全部为空格， istitle（）是否为标题格式‘
— Stratwith（） endwith（）检查字符串是否是“”开头，是则true 否则false
str="this is string example....wow!"
print(str.startswith(‘this‘))
print(str.startswith(‘string‘,8))
print(str.startswith(‘this‘,2,4))
输出结果
True
True
False
— Expandtabs（tabsize=8）
str="this is \tstring example....wow!"
print("原始字符串："+str)
print("替换\\t符号："+str.expandtabs ())
print("使用16空格替换\\t："+str.expandtabs (16))
输出结果
原始字符串：this is string example....wow!
替换\t符号：this is string example....wow!
使用16空格替换\t：this is string example....wow!
1.4 元组tuple 关于元组的功能
元组和列表相似，或者说是列表的二次加工，它是由括号 逗号 和元素组成 而且不同点是一级元素不可被修改，不能被增添或删除
元组的格式 tu=(11,11,111,1111,111,111111,1111111111)
—索引和切片
v1 = tu[0]
v2 = tu[0:2]
print(v1,v2)
—可以被for循环，可认为为迭代对象，可与 字符串 列表 元组 相互转换
for i in tu:
print(i)
count（22）获取指定元素出现的次数
index()find功能一样，而且常用的运算符len（） tuple（）元祖转换 max和min
1.5字典 dictionary 关于字典的功能
补充：创建字典的新方法
>>> qd=dict(name="asdf",age=23)
>>> print(qd)
{‘name‘: ‘asdf‘, ‘age‘: 23}
— copy() /dict2=dict1.copy（）/￥关于浅拷贝和深拷贝￥
在编程中copy都不简单，都知道一句话 对象有类型，变量无类型，变量是个标签
所以判定就要用到 id()
>>> a=5
>>> b=a
>>> b
5
>>> id(a)
1832348816
>>> id(b)
1832348816
由上面的可以看出来5只有一个不过是贴了两个标签 其实其他的数据类型都一样
那么怎么辨别呢 有上面的例子就知道而用copy(浅拷贝)
>>> qd=dict(name="asdf",age=23)
>>> bg=qd
>>> bg
{‘name‘: ‘asdf‘, ‘age‘: 23}
>>> id(bg)
2794260150096
>>> id(qd)
2794260150096
>>> bg=qd.copy()
>>> bg
{‘name‘: ‘asdf‘, ‘age‘: 23}
>>> id(bg)
2794260269168
>>> id(qd)
2794260150096
深入研究：
>>> x={"name":"qiwsir","lang":["python","java""c"]}
>>> y=x.copy()
>>> y
{‘name‘: ‘qiwsir‘, ‘lang‘: [‘python‘, ‘javac‘]}
>>> id(x)
2794260143488
>>> id(y)
2794260269024
Y是从x拷贝过来的。两个在内存是不同的
>>> y["lang"].remove("python")
应该只剩[“javac”],而结果是
>>> y
{‘name‘: ‘qiwsir‘, ‘lang‘: [‘javac‘]}
>>> x
{‘name‘: ‘qiwsir‘, ‘lang‘: [‘javac‘]}
为什么会这样？？？？？
>>> y["name"]="laopi"
>>> y
{‘name‘: ‘laopi‘, ‘lang‘: [‘javac‘]}
>>> x
{‘name‘: ‘qiwsir‘, ‘lang‘: [‘javac‘]}
为什么列表中不管用呢？？
>>> id(x)
2794260143488
>>> id(y)
2794260269024
>>> id(x["lang"])
2794260287624
>>> id(y["lang"])
2794260287624
>>> id(x["name"])
2794260162520
>>> id(y["name"])
2794260036664
根本原因是因为 python在存基本类型的数据时候，就在内存从新建一个房间，如果不是基本类型的 ，就不会新建而是用标签引用，而对于深拷贝就会用到import导入模块copy.deeep.copy()
>>> import copy
>>> z=copy.deepcopy(x)
>>> z
{‘name‘: ‘qiwsir‘, ‘lang‘: [‘javac‘]}
>>> id(x["lang"])
2794260287624
>>> id(z["lang"])
2794260288200
可以看出就不一样 ，再测试一下
>>> x
{‘name‘: ‘qiwsir‘, ‘lang‘: [‘javac‘]}
>>> x["lang"].remove(‘javac‘)
>>> x
{‘name‘: ‘qiwsir‘, ‘lang‘: []}
>>> z
{‘name‘: ‘qiwsir‘, ‘lang‘: [‘javac‘]}
>>> x["lang"].append(‘javac‘)
>>> x
{‘name‘: ‘qiwsir‘, ‘lang‘: [‘javac‘]}
--—clear（） dict.clear() 清空所有字典中的元素
>>> x
{‘name‘: ‘qiwsir‘, ‘lang‘: [‘javac‘]}
>>> x.clear()
>>> x
{}
Clear() 和 del 不要以为功能一样 因为del是删除而不是清空
>>> z
{‘name‘: ‘qiwsir‘, ‘lang‘: [‘javac‘]}
>>> del z
>>> z
Traceback (most recent call last):
File "<pyshell#68>", line 1, in <module>
z
NameError: name ‘z‘ is not defined
— get() dict.get() 意思是 d[k] if k in d else d 就返回其值 否则就返回none,都不会影响字典原来的形式
>>> d={‘lang‘:"python"}
>>> d
{‘lang‘: ‘python‘}
>>> d.get("lang")
‘python‘
>>> print(d.get("name"))
None
>>> d.get("name")
>>> d["name"]
Traceback (most recent call last):
File "<pyshell#81>", line 1, in <module>
d["name"]
KeyError: ‘name‘
— setdefault（） dict.setdefault (“a”，“b”) 功能与get（执行）差不多，后面的就不同了
如果键不在其中，就在字典中加上这个键值对 如果有就不会进行这一步了。
>>> d
{‘lang‘: ‘python‘}
>>> d.setdefault("lang")
‘python‘
>>> d.setdefault("name","qiwsir")
‘qiwsir‘
>>> d
{‘lang‘: ‘python‘, ‘name‘: ‘qiwsir‘}
>>> d
{‘lang‘: ‘python‘, ‘name‘: ‘qiwsir‘}
>>> d.setdefault ("wed")
>>> d
{‘lang‘: ‘python‘, ‘name‘: ‘qiwsir‘, ‘wed‘: None}
— pop() 和popitem（） 在列表中删除的有pop和remove，其功能在字典中也差不多
区别是lis.remove()用于删除指定的元素，而list.pop（）是用于删除指定索引的元素，
如果不提供索引就没默认删除最后一个。
>>> d
{‘lang‘: ‘python‘, ‘name‘: ‘qiwsir‘, ‘wed‘: None}
>>> d.pop("lang")
‘python‘
>>> d
{‘name‘: ‘qiwsir‘, ‘wed‘: None}
这里和列表不同这里的pop(参数) 不能省的 而且如果删除字典中没有的
键值对就会报错
—popitem() 这里哦没有s,而且删除的内容会变成元组tuple。
>>> d={"name":"kong weixin","lang":"python","网站":"www.itdiffer.com"}
>>> d
{‘name‘: ‘kong weixin‘, ‘lang‘: ‘python‘, ‘网站‘: ‘www.itdiffer.com‘}
>>> d.popitem()
(‘网站‘, ‘www.itdiffer.com‘)
>>> d.popitem()
(‘lang‘, ‘python‘)
>>> d
{‘name‘: ‘kong weixin‘}
>>> d.popitem()
(‘name‘, ‘kong weixin‘)
>>> d
{}
>>> d.popitem()
Traceback (most recent call last):
File "<pyshell#14>", line 1, in <module>
d.popitem()
KeyError: ‘popitem(): dictionary is empty‘
—update（）更新 作用于字典 old_dict.update(new_dict )
>>> d
{‘name‘: ‘kong weixin‘, ‘lang‘: ‘python‘, ‘网站‘: ‘www.itdiffer.com‘}
>>> d1={"name":"kong wei","lang":"python 3.65","网站":"www.uppeer.com"}
>>> d.update (d1)
>>> d
{‘name‘: ‘kong wei‘, ‘lang‘: ‘python 3.65‘, ‘网站‘: ‘www.uppeer.com‘}
>>> d1
{‘name‘: ‘kong wei‘, ‘lang‘: ‘python 3.65‘, ‘网站‘: ‘www.uppeer.com‘}
>>> d.update([("name","kongweixin"),(‘lang‘,‘pyhton plus‘)])
如果添加的时候要用列表含元组
>>> d
{‘name‘: ‘kongweixin‘, ‘lang‘: ‘pyhton plus‘, ‘网站‘: ‘www.uppeer.com‘}
1.6布尔值在存储的时候一般为0 1
#转换的时候bool() a=11111
v=bool(0)
print(v)
#其中假的有 None ‘‘ () [] {}
0======>都是False
1.7 集合set 关于集合的基础功能
集合特点 ：无序，不同元素，元素类型为不可变类型、
*什么为不可变类型*
#&&可变：列表 字典（修改后id不变）
##&&不可变：字符串 元组 数字
格式：
s={1,2,33,3,3,4,4,4,5}
print(s)
type(s)
for i in s:
print(1)
关于特点的实例
s0 = {"cajigf","word","alex","cwcbhehnhj"}
print(s0)#无序的#
#s={[1,2,3,4],1}
print(s)
s1=set("hello")
print(s1)
s=set([‘alex‘,‘alex‘,‘sb‘])
print(s)
关于集合的内置方法
#add()添加 只能有一个参数 更新一个值
s={1,2,3,4,5,6}
s.add(3)
print(s.add(‘s‘)
s.add("3")
#clear()清空
s1=s.copy()
#pop()删除#无序的
s={1,2,3,4,5,6}
s.pop()
#remove() 指定删，不存在会报错
s={1,2,3,4,5,6,"sb"}
s.remove("sb")
print(s)
#discard() 指定删，不存在不会报错
s.discard(‘sb‘)
print(s)
关于集合的优点
python_1=["koy",‘csa‘,‘csaui‘]
linux_1=["koy",‘bnm‘,‘csa‘]
#集合的关系测试
#去重:不能变回原样 （元素无序的）
p_s=set(python_1)
l_s=set(linux_1)
#求交集 符号 &
p_s=set(python_1)
l_s=set(linux_1)
print(p_s.intersection(l_s))
#求并集符号|
p_s=set(python_1)
l_s=set(linux_1)
print(p_s.union(l_s))
#求差集 - 各自（p_s）单有的 print(‘差集‘p_s-l_s)
print("差集",p_s.difference(l_s))#p_s减去共有
print("差集",l_s.difference(p_s))#l_s减去共有
#求交叉补集 ^ 总和减去共有的
print("交叉补集"p_s.symmetric_difference(l_s))
#difference_update()
python_1=["koy",‘csa‘,‘csaui‘]
linux_1=["koy",‘bnm‘,‘csa‘]
p_s=set(python_1)
l_s=set(linux_1)
p_s=p_s-l_s
print(p_s.difference_update(l_s))#p_s=p_s-l_s
#交集为空
s1={1,2}
s2={3,5}
print(s1.isdisjoint(s2))
#s1是s2的子集 (s2包含s1)
s1={1,2}
s2={1,2,3,5}
print(s1.issubset(s2))
#s2是s1的父集
s1={1,2}
s2={1,2,3,5}
print(s2.issuperset(s1) )
#uptate()更新 与并集不同 (可迭代)
s1={1,2}
s2={1,2,3,5}
s1.update(s2)#更新多个值
s1.union(s2)#不更新
print(s1)
#建不可变集合
s=frozenset("hello")
print(s)
name=[‘alex‘,‘alex‘,‘kom‘,"kom",‘lok‘]
s=set(name)#去重
name=list(s)
#name=list(set(s))
###字符串格式化{%s(万能的)}
print(‘i am %s my hobby is alex ‘%‘lhf‘)
# low# print(‘i am %s my hobby is alex ‘+‘lhf‘)
msg=‘i am %s my hobby is %s ‘%(‘lhf‘,‘kcamk‘)
msg=‘i am %s my hobby is a %s‘%(‘lhf‘,‘1‘)#%s(万能的)
msg=‘i am %s my hobby is %d（只能接受数字） ‘%(‘lhf‘,2)
#打印浮点数（小数）
msg="percent%f"%99.5615152156126
msg="percent%.2f"%99.5615152156126#取小数位
#打印百分比
#tp1="percent%.2s"%"vajkbdjvabdvoaui"#截取
tp1="percent%.2f%%"%99.5615152156126
msg=‘i am %（name）s age%(age)d‘%{"name":"alex",‘age‘:18}
#小数
tp1=‘i am %(pp).2f‘%{"pp":12.4566789}
print(‘root‘,‘x‘,‘0‘,‘0‘,sep=":")
#format()格式化
# tp1="i am {},age{},{}".format (‘seven‘,18,"alex") #不一一对应
# print(tp1)
tp1="i am {0},age{2},{1}".format (‘seven‘,18,"alex")
tp1="i am {name},age{age},relly{name}".format (name=‘seven‘,age=18 )
tp1="i am {name},age{age},relly{name}".format (**{‘name‘:‘seven‘,‘age‘:18 })
tp1="i am {0[1]},age{1[1]},relly{name}".format ([1,2,3,],[1,2,3,4] )
tp1="i am {:s},age{:d},mong{:f}".format (‘seven‘,18,8888.8)
tp1="i am {:s},age{:d},".format (*[‘seven‘,18,])
:b 2进制 :o 8进制 :x 16进制 :X16进制 :%显示百分比
1.8补充部分
百分号格式化
%[(name)][flages][width].[percision]typecode
(name) 可选，可用选择指定的key
Flags 可选，可供选择的值
+ 右对齐 正数前加正号， 负数前加负号
- 左对齐 正数前无符号， 负数前加负号
空格 右对齐 正数前加空格， 负数前加负号
0 右对齐 正数前无符号， 负数前加负号 用0 填充空白
Width 可选占宽度
Precision 可选 小数点后保留的位数
typecode 必选
常用格式化：
T0p1=’I am %s’%”alex”
T0p1=’I am %s age %d’%(”alex”,18)
T0p1=’I am %(name)s age%(age)d’%(“name”=”alex”,age=18)
T0p1=’I am %(pp)’% 99.123456
T0p1=’I am %.2f%%’%{“pp”:123.456}
Top1=’percent%.2f’% 99.123546
#Format()格式
T0p1=’I am {},age{},{}’.format(“seven”,18,‘alex’)
Top1=”I am {},age{},{}”,format(“seven”,18,‘alex’)
T0p1=”I am {0},age{1},really{0}”.format(“seven”,18)
T0p1=”I am {0},age{1},really{0}”.format(*[“seven”,18])
T0p1=”I am {name},age{age},really{name}”.format（name=”seven”,age=18）
T0p1=”I am {name},age{age},really{name}”.format（**{name=”seven”,‘age’=18}）
T0p1=”I am {name},age{age},really{name}”.format
([1,2,3],[11,22,33])
T0p1=”I am {：s},age{:d},money{:f}”.format
(“seven”，18,888888)
T0p1=”I am {:s},age{:d}”.format([“seven”,18])
T0p1=”I am {name:s},age{age:d}”.format(“seven”,18)
T0p1=”I am {name:s},age{age:d}”.format(**{“name”:“seven”,”age”:18})
1.1 函数
函数的定义方法：
def test(x)
“the function defintion ”
X+=1
Return x
Def 定义函数关键字
Test 函数名
() 内可定义形参
“” 文件描述（非必要，但是加强建议你的函数添加描述信息）
X+=1 泛指代码块或程序处理逻辑
Return 定义返回值
— 过程与返回值的区别
def test01():
msg="hello the little green frog"
print(msg) 没有返回值的，叫过程， 但还是函数
def test02():
msg="hello the little green frog"
print(msg)
return msg 返回值是对函数的再次循环
t1=test01()
t2=test02()
print(t1)
print(t2)
输出结果：
===
hello the little green frog
hello the little green frog
None 虽然没有返回值，但有none的结果所以还是函数的结果。
hello the little green frog
>>>
总结：
def test01():
pass
def test02():
return 0
def test03():
return 0,10,"hello",{"alex",‘lb‘},{"kongweixin ":"very clever"}
t1=test01()
t2=test02()
t3=test03()
print(‘from test01 return is [%s]:‘ %type(t1),t1)
print(‘from test01 return is [%s]:‘ %type(t2),t2)
print(‘from test01 return is [%s]:‘ %type(t3),t3)
结果：
from test01 return is [<class ‘NoneType‘>]: None
from test01 return is [<class ‘int‘>]: 0
from test01 return is [<class ‘tuple‘>]: (0, 10, ‘hello‘, {‘lb‘, ‘alex‘}, {‘kongweixin ‘: ‘very clever‘})
>>> 返回值=0：返回none
返回值=1：返回objest
返回值>1: 返回值tuple
关于实参和形参的概念： 形参
def calc（x,y）
res=x**y
return res
c=calc(a,b) 实参
print(c)
位置参数：
def calc(x,y): # 位置参数必须在关键字参数左边，如果不满足这个情况就会报
print(x) #如果不满足这个情况就会报错。
print(y)
return x,y
c=calc(1,y=2)
print(c)
输出结果：
1
2
(1, 2)
>>>
实例二
def handle(x,type=‘mysql‘):
print(x)
print(type)
handle("hello","sqlite")
输出结果：
===
hello
sqlite
关键字函数 def calc(x,y):
print(x
print(y)
return x,y
c=calc(x=1,y=2)
print(c)
输出结果：
1
2
(1, 2)
# 参数组 ：关于字典和列表
def test(x,*args,**kwargs):
print(x)
print(args)
print(kwargs)
test(1,1,11,111,1111,"name","konfsjoi"，y=2，z=3)
输出结果：
===
1
(1, 11, 111, 1111, ‘name‘, ‘konfsjoi‘)
{‘y‘: 2, ‘z‘: 3}
>>>
1.2全局变量和局部变量
name="产品经理"
def yangjian():
# name="史正文"
global name
print("我要打",name)
#name=‘小东北‘
print("我要打",name)
yangjian()
输出的是
我要打 产品经理
我要打 产品经理
如果利用局部变量
name="产品经理"
def yangjian():
#name="史正文"
global name
print("我要打",name)
name=‘小东北‘
print("我要打",name)
yangjian()
备注：如果函数的内容无global关键字优先读取局部变量，只能读取全局变量但是不能进行重新赋值name=“fff”。如果函数中有global关键字，变量的本质就是全局的那个变量，可读取可赋值
1.3类（使用和实例）
1.31创建和使用类
对于类来说，类是将对象进行实例化最直接的方式。
创建类
class Dog():
"""一次模拟小狗的简单尝试"""
def __init__(self,name,age):#__init__为两个短横线
"""初始化属性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()+" roll over!")
#_init_被称初始化函数（在类中都叫方法） _init_()是个特殊方法，当你根据实例进行
#创建时python会自动运行它。
my_dog=Dog(‘cvw‘,12)
your_dog=Dog(‘JIJK‘,13)
print("my dog name is "+my_dog.name.title()+"!")
print(‘my dog is ‘+str(my_dog.age)+" years old" )
my_dog.sit()
my_dog.roll_over()
print("\nyour dog name is "+your_dog.name.title()+"!")
print(‘your dog is ‘+str(your_dog.age)+" years old" )
your_dog.sit()
your_dog.roll_over()
使用类和实例
class Car:
"""一次汽车模拟简单测试"""
def __init__(self,make,model,year):
"""初次描述汽车的属性"""
self.make=make
self.model=model
self.year=year
self.odometer_reading=10000
def get_descriptive_name(self):
"""返回整洁的描述信息"""
long_name=str(self.year)+" "+self.make+" "+self.model
return long_name.title()
def read_odometer(self):
"""打印一条指出汽车里程的消息"""
print("This car has "+str(self.odometer_reading)+" miles on it.")
my_new_car=Car(‘jki‘,"zmc",2016)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()
修改属性值(有三种方法进行操作)
class Car:
"""一次汽车模拟简单测试"""
def __init__(self,make,model,year):
"""初次描述汽车的属性"""
self.make=make
self.model=model
self.year=year
self.odometer_reading=0
def get_descriptive_name(self):
"""返回整洁的描述信息"""
long_name=str(self.year)+" "+self.make+" "+self.model
return long_name.title()
def read_odometer(self):
"""打印一条指出汽车里程的消息"""
print("\nThis car has "+str(self.odometer_reading)+" miles on it.")
def update_odometer(self,mileage):#\第二通过方法进行修改\
"""将里程表设置为指定的值"""
self.odometer_reading=mileage
my_new_car=Car(‘宝马x86‘,"zmc",2016)
print(my_new_car.get_descriptive_name(),end="\n 维鑫公司")
#my_new_car.odometer_reading=23#|第一直接进行修改|
#my_new_car.read_odometer()#|然后输出| 第一种
my_new_car.update_odometer(30)#\然后将数据放入其中\ 第二种
my_new_car.read_odometer()#\然后直接输出不用操作
第三种 class Car:
"""一次汽车模拟简单测试"""
def __init__(self,make,model,year):
"""初次描述汽车的属性"""
self.make=make
self.model=model
self.year=year
self.odometer_reading=23
def get_descriptive_name(self):
"""返回整洁的描述信息"""
long_name=str(self.year)+" "+self.make+" "+self.model
return long_name.title()
def read_odometer(self):
"""打印一条指出汽车里程的消息"""
print("\nThis car has "+str(self.odometer_reading)+" miles on it.")
def update_odometer(self,mileage):#\第二通过方法进行修改\
"""将里程表设置为指定的值，
并禁止将里程表进行回调"""
if mileage>=self.odometer_reading: 添加逻辑
self.odometer_reading = mileage
else:
print("\nyou can‘troll back an odometer")
my_new_car=Car(‘宝马x86‘,"zmc",2016)
print(my_new_car.get_descriptive_name(),end="\n 维鑫公司")
my_new_car.update_odometer(2)
my_new_car.read_odometer()
my_new_car=Car(‘宝马123‘,"zmc",2018)
print(my_new_car.get_descriptive_name(),end="\n 维鑫公司")
my_new_car.update_odometer(10)
my_new_car.read_odometer()
1.32 对属性的值进行递增
class Car:
"""一次汽车模拟简单测试"""
def __init__(self,make,model,year):
"""初次描述汽车的属性"""
self.make=make
self.model=model
self.year=year
self.odometer_reading=23
def get_descriptive_name(self):
"""返回整洁的描述信息"""
long_name=str(self.year)+" "+self.make+" "+self.model
return long_name.title()
def read_odometer(self):
"""打印一条指出汽车里程的消息"""
print("\nThis car has "+str(self.odometer_reading)+" miles on it.")
def update_odometer(self,mileage):#\第二通过方法进行修改\
"""将里程表设置为指定的值，
并禁止将里程表进行回调"""
if mileage>=self.odometer_reading:
self.odometer_reading = mileage
else:
print("\nyou can‘troll back an odometer")
def increment_odometer(self,miles):
"""将里程表增加指定的量"""
self.odometer_reading +=miles
my_used_car=Car("subaru","outblack",2003)
print(my_used_car.get_descriptive_name(), end="\n 维鑫公司")
my_used_car.update_odometer(23500)
my_used_car.read_odometer()
my_used_car.increment_odometer(100)
my_used_car.read_odometer()
1.33 继承
子类的方法__init__() 在创建子类的时候要将父类的所有的属性赋值，为此，子类的方法__init__()需父类支援
class Car:
"""一次汽车模拟简单测试"""
def __init__(self,make,model,year):
"""初次描述汽车的属性"""
self.make=make
self.model=model
self.year=year
self.odometer_reading=23
def get_descriptive_name(self):
"""返回整洁的描述信息"""
long_name=str(self.year)+" "+self.make+" "+self.model
return long_name.title()
def read_odometer(self):
"""打印一条指出汽车里程的消息"""
print("\nThis car has "+str(self.odometer_reading)+" miles on it.")
def update_odometer(self,mileage):#\第二通过方法进行修改\
"""将里程表设置为指定的值，
并禁止将里程表进行回调"""
if mileage>=self.odometer_reading:
self.odometer_reading = mileage
else:
print("\nyou can‘troll back an odometer")
def increment_odometer(self,miles):
"""将里程表增加指定的量"""
self.odometer_reading +=miles
class ElectricCar(Car):
"""电动车的独特之处"""
def __init__(self,make,model,year): 创建子类，和super的函数
""""初始化父类的属性"""
super().__init__(make,model,year)
super的函数是为了将父类和子类联合起来让子类调用父类的方法，让子类的实例包含所有属性。
给子类定义属性和方法
class Car:
--snip--
class ElectricCar(Car):
"""电动车的独特之处"""
def __init__(self,make,model,year):
""""初始化父类的属性"""
super().__init__(make,model,year)
self.battery=Battery()
def describe_battery(self):
"""打印一条描述电瓶容量的消息"""
print("this car has a "+str(self.battery_size)+"-kwh battery.")
重写父类的方法
class Car:
--snip--
class ElectricCar(Car):
"""电动车的独特之处"""
def __init__(self,make,model,year):
""""初始化父类的属性"""
super().__init__(make,model,year)
self.battery=Battery()
def describe_battery(self):
"""打印一条描述电瓶容量的消息"""
print("this car has a "+str(self.battery_size)+"-kwh battery.")
def fill_gas_tank(self):
"""电动汽车没有油箱"""
print("this car doesn‘t need a gas tank.")
将实例用作属性
class Car:
"""一次汽车模拟简单测试"""
def __init__(self,make,model,year):
"""初次描述汽车的属性"""
self.make=make
self.model=model
self.year=year
self.odometer_reading=23
def get_descriptive_name(self):
"""返回整洁的描述信息"""
long_name=str(self.year)+" "+self.make+" "+self.model
return long_name.title()
def read_odometer(self):
"""打印一条指出汽车里程的消息"""
print("\nThis car has "+str(self.odometer_reading)+" miles on it.")
def update_odometer(self,mileage):#\第二通过方法进行修改\
"""将里程表设置为指定的值，
并禁止将里程表进行回调"""
if mileage>=self.odometer_reading:
self.odometer_reading = mileage
else:
print("\nyou can‘troll back an odometer")
def increment_odometer(self,miles):
"""将里程表增加指定的量"""
self.odometer_reading +=miles
class Battery():
"""一次模拟电动车电瓶的简单尝试"""
def __init__(self,battery_size=70):
‘‘‘初始化电瓶属性‘‘‘
self.battery_size=battery_size
def describe_battery(self):
"""打印一条描述电瓶容量的消息"""
print("This car has a "+str(self.battery_size)+"-kwh battery.")
class ElectricCar(Car):
"""电动车的独特之处"""
def __init__(self,make,model,year):
""""初始化父类的属性"""
super().__init__(make,model,year)
self.battery=Battery()
def describe_battery(self):
"""打印一条描述电瓶容量的消息"""
print("this car has a "+str(self.battery_size)+"-kwh battery.")
def fill_gas_tank(self):
"""电动汽车没有油箱"""
print("this car doesn‘t need a gas tank.")
添加一个battery（）新的方法
class Car:
"""一次汽车模拟简单测试"""
def __init__(self,make,model,year):
"""初次描述汽车的属性"""
self.make=make
self.model=model
self.year=year
self.odometer_reading=23
def get_descriptive_name(self):
"""返回整洁的描述信息"""
long_name=str(self.year)+" "+self.make+" "+self.model
return long_name.title()
def read_odometer(self):
"""打印一条指出汽车里程的消息"""
print("\nThis car has "+str(self.odometer_reading)+" miles on it.")
def update_odometer(self,mileage):#\第二通过方法进行修改\
"""将里程表设置为指定的值，
并禁止将里程表进行回调"""
if mileage>=self.odometer_reading:
self.odometer_reading = mileage
else:
print("\nyou can‘troll back an odometer")
def increment_odometer(self,miles):
"""将里程表增加指定的量"""
self.odometer_reading +=miles
class Battery():
"""一次模拟电动车电瓶的简单尝试"""
def __init__(self,battery_size=70):
‘‘‘初始化电瓶属性‘‘‘
self.battery_size=battery_size
def describe_battery(self):
"""打印一条描述电瓶容量的消息"""
print("This car has a "+str(self.battery_size)+"-kwh battery.")
def get_range(self):
"""打印一条消息，指出电瓶的续航里程"""
if self.battery_size==70:
range=240
elif self.battery_size==85: 根据电瓶电量报告汽车里程
range=270
message="This car can go approximately "+str(range)
message+="miles on a full charge."
print(message)
class ElectricCar(Car):
"""电动车的独特之处"""
def __init__(self,make,model,year):
""""初始化父类的属性"""
super().__init__(make,model,year)
self.battery=Battery()
def describe_battery(self):
"""打印一条描述电瓶容量的消息"""
print("this car has a "+str(self.battery_size)+"-kwh battery.")
def fill_gas_tank(self):
"""电动汽车没有油箱"""
print("this car doesn‘t need a gas tank.")
1.34 导入类
导入单个类将class car 存入一个car.py 文件中
class Car:
"""一次汽车模拟简单测试"""
def __init__(self,make,model,year):
"""初次描述汽车的属性"""
self.make=make
self.model=model
self.year=year
self.odometer_reading=23
def get_descriptive_name(self):
"""返回整洁的描述信息"""
long_name=str(self.year)+" "+self.make+" "+self.model
return long_name.title()
def read_odometer(self):
"""打印一条指出汽车里程的消息"""
print("\nThis car has "+str(self.odometer_reading)+" miles on it.")
def update_odometer(self,mileage):#\第二通过方法进行修改\
"""将里程表设置为指定的值，
并禁止将里程表进行回调"""
if mileage>=self.odometer_reading:
self.odometer_reading = mileage
else:
print("\nyou can‘troll back an odometer")
def increment_odometer(self,miles):
"""将里程表增加指定的量"""
self.odometer_reading +=miles
再命名一个文件并导入car 类的方法
from car import Car
my_new_car=Car(‘ahyygy‘,"a4",2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading=23
my_new_car.read_odometer()
输出及结果
2016 Ahyygy A4
This car has 23 miles on it.
在一个模块中存入多个类
class Car:
"""一次汽车模拟简单测试"""
def __init__(self,make,model,year):
"""初次描述汽车的属性"""
self.make=make
self.model=model
self.year=year
self.odometer_reading=23
def get_descriptive_name(self):
"""返回整洁的描述信息"""
long_name=str(self.year)+" "+self.make+" "+self.model
return long_name.title()
def read_odometer(self):
"""打印一条指出汽车里程的消息"""
print("\nThis car has "+str(self.odometer_reading)+" miles on it.")
def update_odometer(self,mileage):#\第二通过方法进行修改\
"""将里程表设置为指定的值，
并禁止将里程表进行回调"""
if mileage>=self.odometer_reading:
self.odometer_reading = mileage
else:
print("\nyou can‘troll back an odometer")
def increment_odometer(self,miles):
"""将里程表增加指定的量"""
self.odometer_reading +=miles
class Battery():
"""一次模拟电动车电瓶的简单尝试"""
def __init__(self,battery_size=70):
‘‘‘初始化电瓶属性‘‘‘
self.battery_size=battery_size
def describe_battery(self):
"""打印一条描述电瓶容量的消息"""
print("This car has a "+str(self.battery_size)+"-kwh battery.")
def get_range(self):
"""打印一条消息，指出电瓶的续航里程"""
if self.battery_size==70:
range=240
elif self.battery_size==85:
range=270
message="This car can go approximately "+str(range)
message+="miles on a full charge."
print(message)
class ElectricCar(Car):
"""电动车的独特之处"""
def __init__(self,make,model,year):
""""初始化父类的属性"""
super().__init__(make,model,year)
self.battery=Battery()
def describe_battery(self):
"""打印一条描述电瓶容量的消息"""
print("this car has a "+str(self.battery_size)+"-kwh battery.")
def fill_gas_tank(self):
"""电动汽车没有油箱"""
print("this car doesn‘t need a gas tank.")
导入模块car 的模块有有两种方法举例如下：
第一种
from car import Car
my_new_car=Car(‘ahyygy‘,"a4",2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading=23
my_new_car.read_odometer()
第二种
import car
my_beetle=car.Car("volkswagen","beetle",2016)
print(my_beetle.get_descriptive_name())
my_tesla=car.ElectricCar("CAKL",‘cajk‘,2016)
print(my_tesla.get_descriptive_name())
输出结果
2016 Ahyygy A4
This car has 23 miles on it.
2016 Volkswagen Beetle
2016 Cakl Cajk
标签：指定元素 ssi 数值 长度 sub nio 理解 etl wing
原文地址：https://www.cnblogs.com/kwkk978113/p/9600063.html
