华为云实验沙箱体验——Python代码基础知识

写这个是因为我们cv老师让我们体验下华为的AI Gallery，之前就体验过类似的课程——回形针的“基本操作”（jibencaozuo.com），个人感觉还不错，今天来试下华为的学习课程。
一.Python编程基础
1.Print语法

print("XDU-ldx")  #打印 西电李岱勋 字样

str = 'H U A W E I'

for i in str:
    print (i) # 输出后自动换行  
    #str表示输入一段字符串 
    # i不存在字符串中，因此一直打印至字符结束
    
for j in str:
    print (j,end='') # 输出后不换行继续输出下一个字符

样例如下：

# 导入工具包
import sys  # 导入sys模块
print(sys.platform)  # 打印系统平台

2.数值

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，不同精度的类型的数字相加默认取高精度类型作为结果

3.字符串

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：合并和重复

4.列表 ：python中的列表是一个功能强大的集合，用中括号表示。列表的数据类型可以不一样，可以列表中包含列表。

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 ']
list1 = [12, 45, 32, 55]
# list.sort(cmp=None, key=None, reverse=False)：cmp为可选参数, 如果指定了该参数，会使用该参数的方法进行排序。key是用来进行比较的元素。reverse为排序规则，False为升序。

list1.sort() # 对列表进行排序
print(list1) # 输出[12, 32, 45, 55]
# list.reverse()：反向列表中元素。
list1.reverse() # 对列表进行逆置
print(list1) # 输出[55, 45, 32, 12]

Python enumerate() 函数
用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中，（从0开始）。

5.元组 ：Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

T=(1, 2, 3) #创建元组
print(T + (4, 5))  #元组合并，输出：(1, 2, 3, 4, 5)
t=(42, )           #只有一个元素的元组，区别于数字
tuple1 = (12, 45, 32, 55, [1, 0, 3]) # 创建元祖
tuple1[0] = "good"    # 程序异常，元组的不可变性
tuple1[4][0] = 2      # 元组中可变的元素是可以变得
print(tuple1)         # (12, 45, 32, 55, [2, 0, 3])

6.字典： 字典是数据的无序集合，用于存储数据值。与其他仅将单个值作为项的数据类型不同，字典具有键-值对。字典中的键和值之间用冒号“:”分隔，而键-值对之间用逗号“,”分隔，所有键-值对用花括号“{}”括起来。

# 字典的三种赋值操作
x = {
     'food':'Spam', 'quantity':4, 'color':'pink'}
X =dict(food='Spam', quantity=4, color='pink')
x = dict([("food", "Spam"),("b", "2"), ("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.get('name'))  # 输出None
print(d.get('name', '键值不存在！')) # 输出 键值不存在
print(d.keys())    # 输出dict_keys(['food', 'quantity', 'color'])
print(d.values())  # 输出dict_values(['Spam', 4, 'pink'])
print(d.items())   

# 输出 dict_items([('food', 'Spam'), ('quantity', 4), ('color', 'pink')])
d.clear() # 清空字典中的所有数据
print(d)  # 输出 {}
del(d)    # 删除字典
print(d)  # 程序异常，提示“d”未定义

7.集合：

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 len() 函数返回集合元素个数

# set.remove(obj)：移除集合中的指定元素。
sample_set.remove('Data') # 删除元素Data  
print(sample_set)         # {'Prince', 'Techs'}
list2 = [1, 3, 1, 5, 3]
print(list(set(list2)))   # 输出 [1,3,5]，利用集合元素的唯一性进行列表去重
sample_set = frozenset(sample_set) # 不可变集合 frozenset()函数返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

8.深拷贝与浅拷贝： 深拷贝是把要拷贝的对象整体复制一份，存在新开辟的空间里；而浅拷贝指的是，对于要拷贝的对象要复制一份，但是对于其内部的子对象就不复制了，而是直接引用，也就是类似于添加了一个链接而已

import copy
Dict1 = {
      'name':'lee', 'age':89, 'num':[1,2,8]} # 新建字典
Dict_copy = Dict1.copy()          # 浅拷贝
Dict_dcopy = copy.deepcopy(Dict1) # 深拷贝
Dict1['num'][1] = 6               # 修改原数据中嵌套列表的值
print('Dict1:' + str(Dict1), ' Dict_copy:' +str(Dict_copy),' Dict_dcopy:' + str(Dict_dcopy))

9. if判断语句：

#根据输入的分数判断
# input()：用于接收输入。
score = input("请输入你的分数") # input函数接收输入，为字符串类型
score = float(score) # 将分数转化为数字类型

# try:… except Exception:… 是Python中用于捕获异常的语句，如果try中的语句出现错误，则会执行except中的语句。
try:
    if 100 >= score >= 90: # 判断输入的值是否大于等级分数
        print("优")    # 满足条件后输出等级
    elif 90 > score >= 80:
        print("良")
    elif 80 > score > 0:
        print("中")
    else:
        print("差")
        
except Exception:
    print("请输入正确的分数")

10. 循环语句：

#while循环
i = 0          # 新建i变量
while i < 9:     # 设置循环条件
    i += 1       # 每次循环i增加1
    if i == 3: # 判断条件是否满足
        print("跳出此次循环")
        continue # continue跳出当前的这一次循环
    if i == 5:
        print("跳出当前大的循环")
        break # 跳出当前的大的循环
    print(i)

11.函数

def fibs(num):      # 位置参数
    result = [0, 1]  # 新建列表存储数列的值
    for i in range(2, num):   # 循环num-2次
        a = result[i - 1] + result[i - 2]
        result.append(a)     # 将值追加至列表
    return result   # 返回列表
print(fibs(5))
# 输出：[0, 1, 1, 2, 3]

12.类 :如果多个函数需要反复使用同一组数据，使用类来处理，会很方便

class Greeter(object):        # 新建类，继承object
    def __init__(self, name): # 初始化类
        self.name = name      # 创建一个实例变量
        
    # 实例方法
    def greet(self, loud=False):
        if loud:
            print('HELLO, %s!' % self.name.upper())
        else:
            print('Hello, %s' % self.name)
g = Greeter('Fred')     # 创建Greeter类的一个实例
g.greet()               # Hello,Fred    调用实例方法，使用默认参数
g.greet(loud = True)    # HELLO, FRED  调用实例方法，自定义参数

13.多线程： 线程（Thread）也叫轻量级进程，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是进程中的实际运作单位。线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行

import threading  #导入threading模块

from time import sleep, ctime  #导入时间模块

def work1():  #定义方法
    for i in range(3):
        print("work1正在执行...%d"%i)
        sleep(1)

def work2(): #定义方法
    for i in range(3):
        print("work2正在执行...%d"%i)
        sleep(1)

if __name__ == '__main__':
    print('---开始---:%s'%ctime())

    t1 = threading.Thread(target=work1)# 线程1
    t2 = threading.Thread(target=work2)# 线程2
    
    # 启动线程
    t1.start()
    t2.start()

    sleep(5)
print('---结束---:%s'%ctime())

import threading
import time
g_num = 0

def test1(num):
    global g_num	# 使用全局变量
    for i in range(num):
        mutex.acquire()  # 上锁
        g_num += 1
        mutex.release()  # 解锁
    print("---test1---g_num=%d"%g_num)

def test2(num):
    global g_num
    for i in range(num):
        mutex.acquire()  # 上锁
        g_num += 1
        mutex.release()  # 解锁

    print("---test2---g_num=%d"%g_num)

# 创建一个互斥锁
# 默认是未上锁的状态，可以删除锁后查看资源争夺的结果
mutex = threading.Lock()

# 创建2个线程，让他们各自对g_num加1000000次
p1 = threading.Thread(target=test1, args=(1000000,))
p1.start()

p2 = threading.Thread(target=test2, args=(1000000,))
p2.start()

# 等待计算完成
time.sleep(5)

print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

14.正则表达式： 正则表达式是一个很强大的字符串处理工具，几乎任何关于字符串的操作都可以使用正则表达式来完成。

import re 
phone = "2019-0101-000 # 这是一个电话号码"

# 删除字符串中的 Python注释 
num = re.sub(r'#.*$', "", phone)
print("电话号码是: ", num)

# 删除非数字(-)的字符串 
num = re.sub(r'\D', "", phone)
print("电话号码是 : ", num)

15.魔法方法： 魔法方法是python内置方法，不需要主动调用，存在的目的是为了给python的解释器进行调用，几乎每个魔法方法都有一个对应的内置函数，或者运算符，当我们对这个对象使用这些函数或者运算符时就会调用类中的对应魔法方法，可以理解为重写这些python的内置函数。

class Dog(object):  #定义一个类
    def __init__(self, name):
        self.name = name 
        print("小狗：%s"%(self.name))
        
dog = Dog("dog")