Python 语言入门

Python 在各领域的应用已经非常广泛了，尤其是最近热门的人工智能等领域。

现在开始学习 Python 语言基础，后面利用强大的 工具 库，想必事半功倍。

Python 基础语法

1、Python 的注释：

# 单行注释
print ("Hello, Python!") # 单行注释

'''
多行注释
多行注释
'''

"""
多行注释
多行注释
"""

单行注释使用 # 号，多行注释使用 ''' 和 """ 。

2、Python 的行与缩进

Python 中使用缩进表示代码块，不使用 {} 。

if True:
    print ("True")
else:
    print ("False")

如果缩进不一致，会导致错误。

Python 中一条语句换行需要使用反斜杠（ \ ）表示：

total = item_one + \
        item_two + \
        item_three

3、end 关键字

# Fibonacci series: 斐波纳契数列
a, b = 0, 1
while b < 1000:
    print(b, end=',')
    a, b = b, a+b

# 1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

关键字 end 可以用于将结果输出到同一行，或者在末尾添加不同的字符。

Python 基本数据类型

Python 中的变量不需要声明。

Python3 中有六个标准的数据类型：

Number（数字）、String（字符串）、Tuple（元组）、List（列表）、Set（集合）、Dictionary（字典）。

其中前三个为不可变数据类型，后三个为可变数据类型。

1、Number（数字）：Python3 支持 int、float、bool、complex（复数）。

其中 在 Python3 中 True 和 False 为关键字，值分别为 1 和 0，可以和数字相加。

2、String（字符串）：使用单引号 ' 或双引号 " 括起来，使用反斜杠 \ 转义特殊字符。

str = 'wshunli'

print(str)           # 输出字符串
print(str[0])        # 输出字符串第一个字符
print(str[2:4])      # 输出第三个开始到第四个的字符
print(str[0:-1])     # 输出第一个到倒数第二个的所有字符
print(str[2:])       # 输出从第三个开始的后的所有字符
print(str * 2)       # 输出字符串两次
print(str + ".com")  # 连接字符串

# wshunli
# w
# hu
# wshunl
# hunli
# wshunliwshunli
# wshunli.com

Python 三引号：一个字符串跨多行。

para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print(para_str)

# 这是一个多行字符串的实例
# 多行字符串可以使用制表符
# TAB (      )。
# 也可以使用换行符 [ 
#  ]。

3、List（列表）：列表可以完成大多数集合类的数据结构实现。方括号 [] 表示。

列表中元素的类型可以不同，支持数字，字符串以及列表（嵌套）。

列表的索引和截取和字符串类似；但是支持第3个参数表示截取步长。

letters = ['w','s','h','u','n','l','i']
letters[1:4:2]

# ['s','u']

4、Tuple（元组）：元素不能修改的列表。小括号 () 表示。

虽然 Tuple 的元素不可改变，但可以包含可变的对象，比如 List 列表。

String、List 和 Tuple 都属于 Sequence（序列）。

5、Set（集合）：集合元素之间不相同、不可变、无序。大括号 {} 表示。

集合运算：

a = set('abracadabra')
b = set('alacazam')

print(a)
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

# {'b', 'a', 'c', 'r', 'd'}
# {'b', 'd', 'r'}
# {'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
# {'a', 'c'}
# {'l', 'r', 'z', 'm', 'b', 'd'}

6、Dictionary（字典）：无序的 键(key) : 值(value) 的集合。大括号 {} 表示。

其中 键(key) 为不可变类型。在同一个字典中，键(key) 必须是唯一的。

tinydict = {'name': 'wshunli', 2: 1, 'site': 'wshunli.com'}

print (tinydict)          # 输出完整的字典
print (tinydict['name'])  # 输出键为 'one' 的值
print (tinydict[2])       # 输出键为 2 的值
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

# {'name': 'wshunli', 2: 1, 'site': 'wshunli.com'}
# wshunli
# 1
# dict_keys(['name', 2, 'site'])
# dict_values(['wshunli', 1, 'wshunli.com'])

基本数据类型的创建：

list = []    # 构造 0 个的列表
tup1 = ()    # 构造 0 个的元组
tup2 = (20,) # 构造 1 个的元组
set = set()  # 构造 0 个的集合
dirt = []    # 构造 0 个的字典

Python 运算符

（1）Python 算术运算符：+、-、 、/、%、* 、//

** 幂 - 返回 x 的 y 次幂

a**b       # a 的 b 次方

// 取整除 - 向下取接近除数的整数

>>> 9//2   # 4
>>> -9//2  # -5

（2）Python 比较运算符：==、!=、>、>=、<、<=

（3）Python 赋值运算符：=、+=、-=、 =、/=、%=、* 、//=

（4）Python 位运算符：&、|、^ 、~ 、<<、>>

（5）Python 逻辑运算符：and、or、not

（6）Python 成员运算符：in、not in

（7）Python 身份运算符：is、is not

is 是判断两个标识符是不是引用自一个对象；

is not 是判断两个标识符是不是引用自不同对象

Python 条件控制

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

在 Python 中没有 switch – case 语句。

Python 循环语句

1、While 循环

在 while … else 在条件语句为 false 时执行 else 的语句块：

count = 0
while count < 3:
   print (count, " 小于 3")
   count = count + 1
else:
   print (count, " 大于或等于 3")

# 0  小于 3
# 1  小于 3
# 2  小于 3
# 3  大于或等于 3

2、For 循环：遍历任何序列的项目，如列表、字符串。

for <variable> in <sequence>:
    <statements>
else:
    <statements>

3、range() 函数

range() 函数用于生成数列：

for i in range(5):
    print(i, end=',')

for i in range(5, 9):
    print(i, end=',')

for i in range(0, 10, 3):
    print(i, end=',')

for i in range(-1, -10, -3):
    print(i, end=',')

list(range(5))

# 0,1,2,3,4,
# 5,6,7,8,
# 0,3,6,9,
# -1,-4,-7,
# [0, 1, 2, 3, 4]

结合 range() 和 len() 函数遍历一个序列的索引：

a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):
     print(i, a[i])

# 0 Google
# 1 Baidu
# 2 Runoob
# 3 Taobao
# 4 QQ

4、pass 语句

Python pass是空语句，是为了保持程序结构的完整性。

while True:
    pass  # 等待键盘中断 (Ctrl+C)

for letter in 'wshunli':
    if letter == 'n':
        pass
        print('执行 pass 块')
    print('当前字母 :', letter)

print("Good bye!")

# 当前字母 : w
# 当前字母 : s
# 当前字母 : h
# 当前字母 : u
# 执行 pass 块
# 当前字母 : n
# 当前字母 : l
# 当前字母 : i
# Good bye!

Python 迭代器与生成器

1、迭代器：用于遍历集合元素。

（1）迭代器的使用

迭代器有两个基本的方法： iter() 和 next() 。

list = [1, 2, 3, 4]
it = iter(list)             # 创建迭代器对象
print(next(it), end=',')    # 输出迭代器的下一个元素
print(next(it), end=',')    # 输出迭代器的下一个元素

# 1,2,

迭代器可以使用 for 语句进行遍历：

list=[1, 2, 3, 4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print(x, end=",")

# 1,2,3,4,

（2）迭代器的创建

在类中实现 __iter__() 与 __next__() 两个方法。

class MyIter:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        x = self.a
        self.a += 1
        return x

myIter = MyIter()
iter = iter(myIter)

print(next(iter), end=",")
print(next(iter), end=",")
print(next(iter), end=",")
print(next(iter), end=",")
print(next(iter), end=",")

# 1,2,3,4,5,

（3）StopIteration 异常

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况。

class MyIter:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        if self.a <= 10:
            x = self.a
            self.a += 1
            return x
        else:
            raise StopIteration

myIter = MyIter()
iter = iter(myIter)

for x in iter:
    print(x, end=",")

# 1,2,3,4,5,6,7,8,9,10,

2、生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

调用一个生成器函数，返回的是一个迭代器对象。

import sys

def fibonacci(n):  # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n):
            return
        yield a
        a, b = b, a + b
        counter += 1


f = fibonacci(10)  # f 是一个迭代器，由生成器返回生成

while True:
    try:
        print(next(f), end=" ")
    except StopIteration:
        sys.exit()

# 0 1 1 2 3 5 8 13 21 34 55

每次调用生成器函数都会在 yield 处暂停并保存运行状态，返回 yield 结果；在下次执行 next() 函数时从暂停位置继续运行。

Python 函数

1、函数的定义

def hello() :
   print("Hello World!")

hello()

# Hello World!

2、函数的参数及其传递

Python 参数类型：必需参数、关键字参数、默认参数、不定长参数

def printinfo(arg1, arg2, arg3="默认值", *arg4, **arg5):
    print(arg1, end=";")
    print(arg2, end=";")
    print(arg3, end=";")
    print(arg4, end=";")
    print(arg5)

# printinfo();
printinfo("欢迎", "wshunli")
printinfo(arg2="欢迎", arg1="wshunli")
printinfo("欢迎", "wshunli", "访问")
printinfo("欢迎", "wshunli", "访问", "wshunli", ".com")
printinfo("欢迎", "wshunli", "访问", "wshunli", ".com", domain="wshunli", suffix=".com")

# 欢迎;wshunli;默认值;();{}
# wshunli;欢迎;默认值;();{}
# 欢迎;wshunli;访问;();{}
# 欢迎;wshunli;访问;('wshunli', '.com');{}
# 欢迎;wshunli;访问;('wshunli', '.com');{'domain': 'wshunli', 'suffix': '.com'}

其中 arg1 , arg2 属于必需参数，通过关键字传递时可以交换顺序；

arg3 属于默认参数，在没有传值时使用默认值；

arg4 , arg5 属于可变参数， * 元祖形式， ** 字典形式

声明函数时，参数中星号 * 可以单独出现，例如:

def f(a, b, *, c):
    return a + b + c

f(1, 2, 3)    # 报错
f(1, 2, c=3)  # 正常

星号 * 后的参数必须用关键字传入。

不可变类型类似于 传值 传递；可变类型类似于 传址 传递。

3、匿名函数

Python 使用 lambda 来创建匿名函数。

sum = lambda arg1, arg2: arg1 + arg2
# 调用 sum 函数
print("相加后的值为 : ", sum(10, 20))
print("相加后的值为 : ", sum(20, 20))

4、变量作用域

Python 的作用域一共有 4 种：局部作用域、闭包函数外的函数中、全局作用域、内置作用域（内置函数所在模块的范围）

g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

内置作用域是通过一个名为 builtin 的标准模块来实现的：

import builtins
dir(builtins)

改变变量的作用域：使用 global 和 nonlocal 关键字。

num1 = 1
num2 = 2

def outer():
    global num1        # global 关键字
    print("outer>>num1=", num1)
    num1 = 123
    print("outer>>num1=", num1)

    num2 = 20
    def inner():
        nonlocal num2  # nonlocal 关键字
        print("inner>>num2=", num2)
        num2 = 456
        print("inner>>num2=", num2)

    inner()
    print("outer>>num2=", num2)

outer()
print("num1=", num1)
print("num2=", num2)

# outer>>num1= 1
# outer>>num1= 123
# inner>>num2= 20
# inner>>num2= 456
# outer>>num2= 456
# num1= 123
# num2= 2

其中 global : 局部作用域 -> 全局作用域； nonlocal : 局部作用域 -> 闭包函数外的函数中

Python 模块

在 Python 中将一些方法和变量保存在文件中以供其他程序使用。

1、import 语句

import module1[, module2[,... moduleN]

2、from … import 语句：仅导入指定的部分（函数、变量）到当前命名空间中。

from modelname import name1[, name2[, ... nameN]]

__name__ 属性：值为 '__main__' 代表模块自身在运行，否则是被引入的。

dir() 函数：列出模块内定义的所有名称。

Python 异常处理

Python 中使用 try 及 except 处理异常：

while True:
    try:
        x = int(input("Please enter a number: "))
        break
    except ValueError:
        print("Oops!  That was no valid number.  Try again   ")

# Please enter a number: w
# Oops!  That was no valid number.  Try again   
# Please enter a number: 1

同时处理多个异常，可使用元组元组表示：

except (RuntimeError, TypeError, NameError):
        pass

Python 使用 raise 语句抛出一个指定的异常。

如果本文对您有所帮助，且您手头还很宽裕，欢迎打赏赞助我，以支付网站服务器和域名费用。 您的鼓励与支持是我更新的最大动力，我会铭记于心，倾于博客。

本文链接： https://www.wshunli.com/posts/fa771b3.html