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_three3、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.comPython 三引号：一个字符串跨多行。
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 大于或等于 32、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 QQ4、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):
passPython 使用 raise 语句抛出一个指定的异常。
评论 (0)