用ModelArts实战彻底学会python【玩转华为云】

本文的主要内容有：

• 一 python有啥特点及不足
• 二 语法基础必会
• 三py的基础语法详解
• 四 py的高级语法详解

一 🏅 python有啥特点及不足

历史哪些我就不说喽，直接点python提供了高效的数据结构，还能简单有效地面向对象编程这个大家估计熟。Python语法与它的动态性，以及解释型语言的本质，让它成为多数平台上写脚本和快速开发应用首选编程语言，随着版本的不断更新与语言新功能的添加，逐渐被用于独立的、大型项目的开发；

最重要Python它的解释器易于扩展，也就是说使用C或C++（或者其他可以通过C调用的语言）能扩展新的功能和数据类型这个就非常很棒，Py也可用于可定制化软件中的扩展程序语言，并且Python丰富的标准库，提供了适用于各个主要系统平台的源码或机器码；

二 🎲 语法基础必会

另外本文用华为云提供的JupyterLab，来完成代码测试输出哈，如果你在使用 JupyterLab 过程中碰到报错，请参考《ModelArts JupyterLab常见问题解决办法》尝试解决问题；

或者戳这里啊：https://developer.huaweicloud.cn/develop/aigallery/article/detail?id=03676d0a-0630-4a3f-b62c-07fba43d2857

print("Hello world")  #打印 Hello world 字样

str_1='H U A W E I'

for i in str_1:
    print (i) # 输出后能自动换行

for j in str_1:
    print (j, end='') # 输出后不换行继续输出下一个字符//

结果如下：

Hello world
H
 
U
 
A
 
W
 
E
 
I
H U A W E I

# 导入工具包
import sys  #上面还是太简单，咱们导入sys模块
print(sys.platform)  # 打印系统平台
# 单行注释
"""
这是多行注释
.....
"""

# 多行语句可以写在一起，但我不推荐这种写法
print("语句1");print("语句2")

s = input("请输入：")  #接受一个标准输入数据，返回string类型，按Enter键确认输入
print(s)
print(type(s))

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

三 🙈 py的基础语法详解

3.1 字符串咋操作

字符串怎么操作,首先字符串是由Unicode码点组成的不可变序列，提醒下“r”：字符换变为原始字符串。“\”：字符转意；下面这段代码看似没问题，但是这字符对象不能赋值给数组元素，会出现类型错误的哦

str_2 = 'python'
str_2[0] = 'Z'           # 程序异常
str_3 = 'Z' + str_2[1:]     # 生成了新的字符串 zython，并赋值给str_3
print("str_2 : %s, str_3 : %s"%(str_2, str_3))   # 输出str_2:python，str_3:zython

str_2 = "python" # 变量赋值

# str.split(str="", num=-1)：通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则分隔 num+1 个子字符串,-1表示分割所有。
print(str_2.split('h')) # 输出[‘pyt’,’on’]，根据h对字符串切割

# str.replace(old, new[, max])：返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。
print(str_2.replace('py', 'PY')) # Python，将字符串中的py替换为PY

# print(str_2.islower()):判断字符串是否为小写，是则输出True，否则输出False
print(str_2.islower()) # 输出为True

# print(str_2.isupper()):判断字符串是否为大写，是则输出True，否则输出False
print(str_2.isupper()) # 输出为False

# str.upper()：返回小写字符转化为大写后的值。
print(str_2.upper()) # PYTHON

# str.lower()：返回大写字符转化为小写后的值。
print('PYTHON'.lower()) # python，字符串转小写

# 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

3.2 列表咋整

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

animals = ['cat', 'dog', 'monkey']
​
# list.append(obj)：在列表末尾添加新的对象。
animals.append('fish') # 追加元素
print(animals)         # 输出 ['cat', 'dog', 'monkey', ‘fish’]
​
# list.remove(obj)：移除列表中某个值的第一个匹配项。
animals.remove('fish') # 删除元素fish
print(animals)         # 输出 ['cat', 'dog', 'monkey']
​
# list.insert(index, obj)：用于将指定对象插入列表的指定位置。index：插入位置
animals.insert(1, 'fish') # 在下标1的地方插入元素fish
print(animals)           # 输出 ['cat', ‘fish’, 'dog', 'monkey']
​
# list.pop([index=-1])：要移除列表中对下标对应的元素（默认是最后一个）。Index：下标
animals.pop(1) # 删除下标为1的元素
print(animals) # 输出 ['cat', 'dog', 'monkey']
​
#遍历并获取元素和对应索引  
# 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 ']
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]

打印结果如下

['cat', 'dog', 'monkey', 'fish']

['cat', 'dog', 'monkey']

['cat', 'fish', 'dog', 'monkey']

['cat', 'dog', 'monkey']

(0, 'cat')

(1, 'dog')

(2, 'monkey')

['catcat', 'dogdog', 'monkeymonkey']

[12, 32, 45, 55]

[55, 45, 32, 12]

3.3 元组咋整

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])

3.4 字典是啥

字典是数据的无序集合，用于存储数据值。与其他仅将单个值作为项的数据类型不同，字典具有键-值对。字典中的键和值之间用冒号“:”分隔，而键-值对之间用逗号“,”分隔，所有键-值对用花括号“{}”括起来，重要的是字典的值可以使任意类型，但键是不可变且为唯一的。字典是无序的；

下面是什么错知道吗？名称错误’d’没有定义

# 字典的三种赋值操作
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”未定义

3.5 集合搞懂

集合是一个无序的不重复元素序列。它是可迭代的，没有重复元素(每个元素都是唯一的)的，并且集合之间能进行运算（与异并差）；

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()函数返回一个冻结的集合，冻结后集合不能再添加或删除任何元素

结果如下这样

False
{'Techs', 'Prince', 'Data'}
3
{'Techs', 'Prince'}
[1, 3, 5]

3.6 深浅拷贝问题

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

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))

结果如下这样

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]}

3.7 循环语句

#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

跳出当前大的循环

四 🎯 py的高级语法详解

4.1 函数调用

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]

#再来一个
def hello(greeting='hello', name='world'): # 默认参数
    print('%s, %s!' % (greeting, name))    # 格式化输出
hello()                                    # hello，world    默认参数
hello('Greetings')                         # Greetings，world     位置参数
hello('Greetings', 'universe')             # Greetings，universe     位置参数
hello(name = 'Gumby')                      # hello，Gumby    关键字参数

运行结果如下这样

hello, world!
Greetings, world!
Greetings, universe!
hello, Gumby!

4.2 面对对象-类

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  调用实例方法，自定义参数

4.3 文件操作这个常用

# 使用write方法写文件
with open("f.txt", "w") as f:
    f.write( "www.huawei.cn")

# 使用read方法读取
with open("f.txt", "r") as f:
    print(f.read())

4.4 多线程

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

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())

运行结果如下这样

---开始---:Wed Nov 10 10:35:08 2021

work1正在执行...0

work2正在执行...0

work1正在执行...1work2正在执行...1

咱们加把互斥锁，让两个线程对g_num全局变量加1000000次的最终结果是啥

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)

4.5 正则表达式这个很常用

正则表达式是一个很强大的字符串处理工具，几乎任何关于字符串的操作都可以使用正则表达式来完成;能够对文本匹配、抽取、与/或文本形式的搜索和替换功能提供了基础，用于服务器日志文件的信息检索和匹配；爬虫数据获取等；

import re  #导入正则表达式模块
print(re.match('www', 'www.huawei.cn').span())  # 在起始位置匹配
print(re.match('com', 'www.huawei.cn'))        	#不在起始位置匹配

此处想下什么结果，打印如下所示

(0, 3)
None

咱们重头扫描字符串看下啥结果呢

import re
line = "Cats are smarter than dogs"
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)  #重头开始扫描整个字符串

if searchObj:
    print("searchObj.group() : ", searchObj.group())
    print("searchObj.group(1) : ", searchObj.group(1))
    print("searchObj.group(2) : ", searchObj.group(2))
else:
    print("Nothing found!!" )

打印结果如下这样

searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

利用正则教你如何正确删除字符串

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

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

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

这个结果可以思考下是啥，结果如下这样

电话号码是:  2019-0101-000 
电话号码是 :  20190101000

教你如何正确匹配字符串，你可以暂停思考下

import re
pattern = re.compile(r'\d+')                    # 用于匹配至少一个数字
n = pattern.match('one12twothree34four')        # 查找头部，没有匹配
print(n)

m = pattern.search('one12twothree34four') # 从'e'的位置开始匹配，没有匹配
print(m)
print(m.group())

#最后咱来个切分字符串
import re
s=re.split('\W+', 'www.huawei.cn') #切分字符串
print(s)

打印结果如下这样

None
<_sre.SRE_Match object; span=(3, 5), match='12'>
12

['www', 'huawei', 'com']

4.6 魔法方法别误会

它是python内置方法，不需要主动调用，目的是为了给python的解释器进行调用，所以几乎每个魔法方法都有一个对应的内置函数，或者运算符，当我们对这个对象使用这些函数或者运算符时就会调用类中的对应魔法方法，可以理解为重写这些python的内置函数，没看到没关系看下面

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

class Dog(object):
    def __init__(self, name):
        self.name = name
        
    def __str__(self):
        return "小狗的名字："+self.name
dog = Dog("dog")
print(dog)

class Dog(object):
    def __init__(self, name):
        self.name = name
        
    def __str__(self):
        return "小狗的名字："+self.name
    
    def __repr__(self):
        return "这是小狗%s的对象"%(self.name)
dog = Dog("dog")
dog

打印结果如下这样

小狗：dog

小狗的名字：dog

这是小狗dog的对象