软件定义园区网络的开发与实践-python基础学习笔记
1.数据类型
1.1数值
print(True+False) # 输出 1,True 默认为 1,False 为 0
print(True or False) # 输出 True,关键字 or 执行“或”操作
print(5//2) # 输出 2,//为取整运算符
print(5%2) # 输出 1,%为取余运算符
print(3**2) # 输出 9,**表示乘方操作
print(5+1.6) # 输出 6.6,不同精度的类型的数字相加默认取高精度类型作为结果
1
True
2
1
9
6.6
1.2 字符串
S = 'python' # 给变量 S 赋值 python
# len(obj): 返回对象的长度
print(len(S)) # 输出 6
print(S[0],S[1],S[-1]) # 输出 pyn ,按照索引获取元素
print(S+'1',S*2) # 输出 python1 pythonpython:合并和重复
6
p y n
python1 pythonpython
S = 'python' # 给变量 S 赋值 python
# len(obj): 返回对象的长度
print(S[-2])
o
S = 'python' # 给变量 S 赋值 python
# S[0] = 'Z' # 程序异常,字符串不可变
S1 ='Z'+S[1:] # 生成了新的字符串 Zython,并赋值给 S1
# S[1:]代表第一个字符后的字符串,即 ython
print("S:%s,S1:%s"%(S,S1)) # 输出 S:python,S1:Zython. %s 表示打印字符串
S:python,S1:Zython
S = "python" # 变量赋值
# str.split(str="", num=-1):通过指定分隔符对字符串进行切片,如果参数 num 有指定值,则分隔 num+1 个子字符串,-1 表示分割所有。
print(S.split('h')) # 输出[‘pyt’,’on’],根据 h 对字符串切割
# str.replace(old, new[, max]):返回字符串中的 old(旧字符串) 替换成 new(新字符串)后生成的新字符串,如果指定第三个参数 max,则替换不超过 max 次。
print(S.replace('py','PY')) # PYthon,将字符串中的 py 替换为 PY
# str.upper():返回小写字符转化为大写后的值。
print(S.upper()) # PYTHON
# str.lower():返回大写字符转化为小写后的值。
print('PYTHON'.lower()) # python,字符串转小写
line='aa,bb,ccc,dd\n' # \n 为换行
print(line)
# str.join(sequence):sequence:要连接的序列,返回指定字符连接序列中元素后生成的新字符串。
print(' '.join(['life', 'is' ,'short'])) # 输出 life is short,join 拼接字符串
hw12='%s %s %d' % ('hello','world',12) # 格式化字符串
print(hw12) # 输出 hello world 12
['pyt', 'on']
PYthon
PYTHON
python
aa,bb,ccc,dd
life is short
hello world 12
1.3 列表
[]
animals = ['cat', 'dog', 'monkey'] # 定义列表 animals
# list.append(obj):在列表末尾添加新的对象。
animals.append('fish') # 追加元素
print("末尾添加fish:%s"%animals) # 输出 ['cat', 'dog', 'monkey', ‘fish’]
# list.remove(obj):移除列表中某个值的第一个匹配项。
animals.remove('fish') # 删除元素 fish
print("移除元素fish:%s"%animals) # 输出 ['cat', 'dog', 'monkey']
# list.insert(index, obj):用于将指定对象插入列表的指定位置。index:插入位置
animals.insert(1,'fish') # 在下标 1 的地方插入元素 fish
print("在1的位置插入fish:%s"%animals) # 输出 ['cat', ‘fish’, 'dog', 'monkey']
# list.pop([index=-1]):要移除列表中对下标对应的元素(默认是最后一个)。Index:下标
animals.pop(1) # 删除下标为 1 的元素
print("移除下标为1的元素:%s"%animals) # 输出 ['cat', 'dog', 'monkey']
末尾添加fish:['cat', 'dog', 'monkey', 'fish']
移除元素fish:['cat', 'dog', 'monkey']
在1的位置插入fish:['cat', 'fish', 'dog', 'monkey']
移除下标为1的元素:['cat', 'dog', 'monkey']
遍历
#animals = ['cat', 'dog', 'monkey'] # 定义列表 animals
#enumerate(sequence) :将一个可遍历的数据对象组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
for i in enumerate(animals):
# 元素下标和元素所组成的索引
print(i)
(0, 'cat')
(1, 'dog')
(2, 'monkey')
squares = [x*2 for x in animals] # 批量生成符合规则的元素组成的列表
print(squares) # ['catcat ', 'dogdog ', 'monkeymonkey ']
for i in enumerate(squares):
print(i)
['catcat', 'dogdog', 'monkeymonkey']
(0, 'catcat')
(1, 'dogdog')
(2, 'monkeymonkey')
排序
list1 = [12,45,32,55] # 定义新列表 list1
list1.sort() # 对列表进行排序,默认为从小到大
print(list1) # 输出[12,32,45,55]
# list.reverse():反向列表中元素。
list1.reverse() # 对列表进行逆置
print(list1) # 输出[55,45,32,12]
[12, 32, 45, 55]
[55, 45, 32, 12]
1.4 元组
相当于只读的列表()
T=(1,2,3) # 创建元组
print(T+(4,5)) # 元组合并,输出:(1, 2, 3, 4, 5)
t=(42,) # 只有一个元素的元组,区别于数字
t1=(42)
print(t)
print(t1)
tuple1 = (12,45,32,55,[1,0,3]) # 创建元祖
#tuple1[0] = "good" # 程序异常,元组的不可变性,不可赋值
tuple1[4][0] = 2 # 元组中可变的元素是可以赋值,例子中为[1,0,3]列表中元素
print(tuple1) # (12,45,32,55,[2,0,3])
(1, 2, 3, 4, 5)
(42,)
42
(12, 45, 32, 55, [2, 0, 3])
1.5 字典
{}
# 字典的三种赋值操作
x = {'food':'Spam','quantity':4,'color':'pink'}
x = dict(food='Spam',quantity=4, color='pink')
x = dict([("food", "Spam"),("quantity", "4"),("color","pink")])
# dict.copy():拷贝数据
d =x.copy()
d['color'] = 'red'
print(x) # {'food':'Spam','quantity':4,'color':'pink'}
print(d) # {'food':'Spam','quantity':4,'color':'red'}
#元素访问
#print(d['name']) # 得到错误信息
print(d.get('name')) # 输出 None
print(d.get('name','键值不存在!')) # 输出 键值不存在
print(d.keys()) # 输出 dict_keys(['food', 'quantity', 'color'])
print(d.values()) # 输出 dict_values(['Spam', 4, 'red'])
print(d.items()) # 输出 dict_items([('food', 'Spam'), ('quantity', 4), ('color', 'red')])
d.clear() # 清空字典中的所有数据
print(d) # 输出 {}
del(d) # 删除字典
{'food': 'Spam', 'quantity': '4', 'color': 'pink'}
{'food': 'Spam', 'quantity': '4', 'color': 'red'}
None
键值不存在!
dict_keys(['food', 'quantity', 'color'])
dict_values(['Spam', '4', 'red'])
dict_items([('food', 'Spam'), ('quantity', '4'), ('color', 'red')])
{}
1.6 集合
集合和字典都是{}标识,有何区别?
sample_set = {'Prince', 'Techs'}
print('Data' in sample_set) # 输出 False,in 的作用是检查集合中是否存在某一元素
# set.add(obj):给集合添加元素,如果添加的元素在集合中已存在,则不执行任何操作
sample_set.add('Data') # 向集合中增加元素 Data
print(sample_set) # 输出 {'Prince', 'Techs', 'Data'}
print(len(sample_set)) # 输出 3
print('Data' in sample_set)#In检查是否存在某一元素
# set.remove(obj):移除集合中的指定元素。
sample_set.remove('Data') # 删除元素 Data
print(sample_set) # {'Prince', 'Techs'}
#集合的应用:去重
list2 = [1,3,1,5,3]
print(set(list2)) # 输出{1, 3, 5},利用集合元素的唯一性进行列表去重
print(list(set(list2))) # 输出 [1,3,5]列表
sample_set = frozenset(sample_set) # 不可变集合
False
{'Prince', 'Techs', 'Data'}
3
True
{'Prince', 'Techs'}
{1, 3, 5}
[1, 3, 5]
2. 深拷贝与浅拷贝
import copy #当前程序调用 copy 模块
Dict1 = { 'name': 'lee', 'age':89, 'num':[1,2,8]} # 新建字典
Dict_copy = Dict1.copy() # 浅拷贝
Dict_dcopy = copy.deepcopy(Dict1) # 深拷贝
Dict2=Dict1 # 浅拷贝,直接赋值对象
Dict1['num'][1] = 6 # 修改原数据中嵌套列表的值
print('Dict1:'+str(Dict1)+"\n",'Dict_copy:'+ str(Dict_copy)+"\n",'Dict_dcopy:'+ str(Dict_dcopy)+
"\n",'Dict2:'+str(Dict2))
Dict1:{'name': 'lee', 'age': 89, 'num': [1, 6, 8]}
Dict_copy:{'name': 'lee', 'age': 89, 'num': [1, 6, 8]}
Dict_dcopy:{'name': 'lee', 'age': 89, 'num': [1, 2, 8]}
Dict2:{'name': 'lee', 'age': 89, 'num': [1, 6, 8]}
浅拷贝数据一起被修改,深拷贝数据没有修改,对象赋值为浅拷贝,数据被修改
3.if语句
#根据输入的分数判断
# input():用于接收输入。
score = input("请输入你的分数") # input 函数接收输入,为字符串类型
# try:… except Exception:… 是 Python 中用于捕获异常的语句,如果 try 中的语句出现错误,则会执行 except中的语句。
try:
score = float(score) # 将分数转化为数字类型
if 100>=score>=90: # 判断输入的值是否大于等级分数
print("优") # 满足条件后输出等级
elif 90 > score >= 80:
print("良")
elif 80>score>=60:
print("中")
else:
print("差")
except Exception:
print("请输入正确的分数")
请输入你的分数100
优
4.循环语句
#for循环
for i in range(1,10): # 定义外层循环
for j in range(1,i+1): # 定义内层循环
print ("%d * %d = %2d" % (i , j , i*j), end=" \t ") # 字符串的格式化输出,让打印结果进行对齐
print() # end 属性设置打印结尾符号默认为\n
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81
#while 循环
i = 0 # 新建 i 变量
while i<9: # 设置循环条件
i+=1 # 每次循环 i 增加 1
if i == 3: # 判断条件是否满足
print("跳出此次循环,执行下次循环")
continue # continue 跳出当前的这一次循环
if i == 5:
print("跳出当前大的循环")
break # 跳出当前的大的循环
print(i)
1
2
跳出此次循环,执行下次循环
4
跳出当前大的循环
5.自定义函数
def Print_Hello ( ): # 函数名称,无输入值
print ("Hello,Python.") # 输出
Print_Hello() # 函数调用
Hello,Python.
def hello(greeting='hello',name='world'): # 默认参数
print('%s, %s!' % (greeting, name)) # 格式化输出
hello() # hello,world 无参数则使用默认参数
hello('Greetings') # Greetings,world 位置参数
hello(name='Huawei') # hello,Huawei关键字参数
hello('Greetings','universe') # Greetings,universe 位置参数
hello, world!
Greetings, world!
hello, Huawei!
Greetings, universe!
#不定长参数,使用* 表示元组类型参数,**表示字典类型的参数。
def test (a, b, *c, **d):
print (a)
print (b)
print (c)
print (d)
test (1,2,3,4,5,6,x=10,y=11) #传递的参数会自动区分元组或字典类型
1
2
(3, 4, 5, 6)
{'x': 10, 'y': 11}
#返回值
def plus_one (number):
return int(number)+1
plus_one(10)
11
6.IO操作
# 文件写入
f = open("text.txt", 'w') # 打开文件 text.txt,当文件不存在时会新建一个。w 表示文件模式为写入
Str = input("请输入要写入的内容:") # 内置函数 input 获取控制台的输入
f.write(Str) # 将 Str 写入到文件 f
f.close() # 关闭文件
请输入要写入的内容:hello,world
# 文件读取
f = open("text.txt", 'r') # r 表示文件描述为读取,
print(f.read(6)) # 读取六个字符,当前光标后移六个字符
print(f.read()) # 读取光标所在位置至最后
f.close()
hello,
world
使用上下文管理器操作文件
规定了资源的使用范围。代码开始时候分配资源,结束时释放资源。能够很好的
精简代码和提高代码的可读性
#基本语法为:with 上下文表达式 [as 资源对象]:#as 表示将上下文的返回值赋值给资源对象
with open("text1.txt", 'w') as f: # 使用 with 语句进行文件写入
f.write("python 文件操作")
with open("text1.txt", 'r') as f: # 使用 with 语句读取文件内容
print(f.read())
python 文件操作
7.异常处理
# 制造异常
num1 = input ('请输入第一个数字:')
num2 = input ('请输入第二个数字:') #输入除数为0
print ('第一个数字除以第二个数字为:%f'%(int(num1)/int(num2))) #%f 代表浮点数
请输入第一个数字:10
请输入第二个数字:0
---------------------------------------------------------------------------
ZeroDivisionError Traceback (most recent call last)
<ipython-input-81-6d543e03115c> in <module>
2 num1 = input ('请输入第一个数字:')
3 num2 = input ('请输入第二个数字:') #输入除数为0
----> 4 print ('第一个数字除以第二个数字为:%f'%(int(num1)/int(num2))) #%f 代表浮点数
ZeroDivisionError: division by zero
#使用 try-except 结构捕获异常ZeroDivisionError
try:
num1 = input ('请输入第一个数字:')
num2 = input ('请输入第二个数字:')
print ('第一个数字除以第二个数字为:%f'%(int(num1)/int(num2)))
except ZeroDivisionError:
print ('第二个数不能为 0')
请输入第一个数字:10
请输入第二个数字:0
第二个数不能为 0
#捕获所有异常Exception
try:
num1 = input ('请输入第一个数字:')
num2 = input ('请输入第二个数字:')
print ('第一个数字除以第二个数字为:%f'%(int(num1)/int(num2)))
except Exception as result :
print ('捕获到异常:%s' % result)
请输入第一个数字:string
请输入第二个数字:0
捕获到异常:invalid literal for int() with base 10: 'string'
python完整异常处理:
try:
#语句
except:
#异常处理代码
except:
#另一个异常处理代码
else:
#没有异常的执行代码
finally:
#最后必须执行的代码,无论是否有异常
8.面向对象编程(类)
8.1 创建和使用类
# 赋予了每条小狗蹲下 sit()和打滚roll_over()的能力
class Dog(): # 使用 class 关键字声明一个类
"""模拟狗的行为(方法)"""
def sit(self): # 使用函数定义类的方法,self 表示自身,永远为第一个参数
"""模拟小狗被命令时蹲下"""
print("Dog is now sitting") # 方法中使用 self 访问了 name 属性
def roll_over(self):
"""模拟小狗被命令时打滚"""
print("Dog rolled over!")
dog = Dog() # 创建一个对象,并用 dog 保存它的引用
dog.name = "哈士奇" # 添加表示名字的属性,name 为哈士奇
dog.sit() # 调用方法
dog.roll_over()
print (dog.name)
Dog is now sitting
Dog rolled over!
哈士奇
8.2 类的属性
# 将 name 和 age 两个属性初始化到 Dog 类中
class Dog(): # 使用 class 关键字声明一个类
#模拟狗的属性和行为(方法)
def __init__ (self,name,age): # 初始化类的属性,第一个参数永远都是 self,表示对象自身
#初始化属性 name 和 age
self.name = name
self.age = age
def sit(self): # 使用函数定义类的方法,携带 self 参数
#模拟小狗被命令时蹲下
print(self.name+" is now sitting") # 方法中使用 self 访问了 name 属性
def roll_over(self):
#模拟小狗被命令时打滚
print(self.name+" rolled over!")
dog = Dog("哈士奇",2) # 创建一个对象,并用 dog 保存它的引用
print (dog.age) # 访问属性
dog.sit() # 调用方法
dog.roll_over()
2
哈士奇 is now sitting
哈士奇 rolled over!
8.3 类的封装
通过将属性定义为私有属性,避免
外界随意赋值。
私有属性通过__ (两个下划线前缀)实现
class Dog():
def __init__ (self,name,age):
self.name = name
self.__age = age #将 age 设置为私有属性__age
def get_age(self):
return(self.__age)
dog = Dog('哈士奇','2')
print (dog.name)
#dog.get_age() #调用 get_age()方法,返回参数
print(dog.get_age())
print (dog.__age) #这里程序将报错,显示没有__age 属性,外部无法直接调用
哈士奇
2
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-94-2bd909e4f853> in <module>
9 #dog.get_age() #调用 get_age()方法,返回参数
10 print(dog.get_age())
---> 11 print (dog.__age) #这里程序将报错,显示没有__age 属性,外部无法直接调用
AttributeError: 'Dog' object has no attribute '__age'
8.4 类的继承
本例中构建一个 Dog 的子类 Husky,继承父类的属性和方法
class Dog():
def __init__ (self,name,age):
self.name = name
self.__age = age # 将 age 设置为私有属性__age
def get_age(self):
return self.__age
class Husky(Dog): # 声明一个子类哈士奇,父类为 Dog
pass
mydog = Husky('Larry',3) # 子类继承了父类的构造方法
print (mydog.name) # 子类继承了父类的 name 属性,私有属性无法继承
mydog.get_age() # 子类继承了父类的 get_age()方法
Larry
3
类多态:多态指在不考虑对象类型的情况下使用对象,不关心对象是父类
还是子类,只关心对象的行为(方法)
#父类 Dog,叫声为 Dog shouts
class Dog():
def __init__ (self,name,age):
self.name = name
self.__age = age
def get_age(self):
return self.__age
def shout(self):
print ('Dog shouts,我是狗')
#子类哈士奇,叫声为呜呜
class Husky(Dog):
def shout(self):
print('呜呜,我是哈士奇')
#子类藏獒,叫声为汪汪
class Tibetan_Mastiff(Dog):
def shout(self):
print('汪汪,我是藏獒')
#定义一个函数 sound,调用 shout 方法
def sound(dog):
dog.shout()
#dog1 为哈士奇的对象
dog1 = Husky('Larry',3)
sound(dog1)
#dog2 为 Dog 的对象
dog2=Dog('Richard',2)
sound(dog2)
#dog3 为藏獒的对象
dog3= Tibetan_Mastiff('Sylvia',4)
sound(dog3)
呜呜,我是哈士奇
Dog shouts,我是狗
汪汪,我是藏獒