软件定义园区网络的开发与实践-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，我是狗
汪汪，我是藏獒