[python学习]python3 基础语法_python3语法

一、Python3基础简介

• 变量定义
• 注释使用
• print 输出
• import 导入
• 缩进代码块

1.1 变量定义

Python 中的变量不需要声明，但每个变量在使用前必须赋值，变量赋值以后该变量才会被创建。

#!/usr/bin/python3  
  
# 整型变量  
counterInt = 100  
# 浮点型变量  
milesFlot = 1000.0  
# 字符串类型：  
wordStr01 = '字符串01'  
wordStr02 = "字符串02"  
  
# print默认换行，因此不存在println  
print(counterInt)  
print(milesFlot)  
print(wordStr01)  
print(wordStr02)  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

多变量按如下方式进行赋值：

#!/usr/bin/python3  

# 多变量 赋值
a = b = c = 1
# 多变量 赋值
d, e, f = 1, 2, "xiaxl"

# 内置 type() 函数可以用来查询变量所指的对象类型
print(type(a), type(b), type(c), type(d))
1
2
3
4
5
6
7
8
9

1.2 注释

单行注释以 # 开头：

#!/usr/bin/python3  
  
# 第一个注释  
# 第二个注释  
print("Hello, Python!")
1
2
3
4
5

多行注释可以用多个 # 号，还有 '''’ 和 """：

#!/usr/bin/python3
 
'''
多行注释：一
多行注释：二
'''
 
"""
多行注释：三
多行注释：四
"""
print ("Hello, Python!")
1
2
3
4
5
6
7
8
9
10
11
12

1.3 print 输出

• print 默认换行，因此不存在 println；
• print 若要实现不换行，需要在变量末尾加上 end=""；

#!/usr/bin/python3
 
x="a"
# 换行输出
print( x )
# 不换行输出
print( x, end=" " )
print ("Hello, Python!")
1
2
3
4
5
6
7
8

1.4 import 导入

在 python 用 import 或者 from...import 来导入相应的模块。

• 将整个模块(somemodule)导入： import somemodule
• 从某个模块中导入某个函数： from somemodule import somefunction
• 从某个模块中导入多个函数： from somemodule import firstfunc, secondfunc, thirdfunc
• 将某个模块中的全部函数导入： from somemodule import *

# 导入sys模块
import sys
# 导入特定成员
from sys import argv,path
1
2
3
4

1.5 缩进

python使用缩进来表示代码块，不需要使用大括号 {} 。
另外，同一个代码块的语句必须包含相同的缩进空格数。

#!/usr/bin/python3

if True:
    print ("True")
else:
    print ("False")
1
2
3
4
5
6

二、数据类型

• 基本数值类型
• String 字符串类型
• List 列表
• Tuple 元组
• Set 集合
• Dictionary 字典

2.1 基本数值类型

python3 的基本数值类型包括 int、float、complex、bool

# !/usr/bin/python3  
  
# 长整型：十进制  
counterInt01 = 100  
# 长整型：二进制  
counterInt02 = 0b1010  
# 长整型：十六进制  
counterInt03 = 0x0F  
  
# 布尔  
isRight = True  
  
# 浮点型  
milesFlot = 1000.0  
1
2
3
4
5
6
7
8
9
10
11
12
13
14

可能会有疑问，数值类型中为什么会有bool？
Python3 中，bool 是 int 的子类，因此 True 和 False 可以和数字相加（True=1、False=0）。

数值运算

• 数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数；
• 数值乘方用 ** 表示；

5 + 4  # 加法：9
4.3 - 2 # 减法：2.3
3 * 7  # 乘法：21
2 / 4  # 除法 得到一个浮点数：0.5
2 // 4 # 除法 得到一个整数：0
17 % 3 # 取余：2
2 ** 5 # 乘方：32
1
2
3
4
5
6
7

2.2 String 字符串

String是一个Unicode字符序列，是Python中最重要的数据类型之一。

• String 单引号 ' 和双引号 " 使用作用相同；
• String 三引号(''' 或 """)可以指定一个多行字符串；

# !/usr/bin/python3  
wordStr01 = '字符串01'  
wordStr02 = "字符串02"    
wordStr03 = """字符串段落， 
字符串段落"""  

# print默认换行，因此不存在println  
print(wordStr01)  
print(wordStr02)  
print(wordStr03)
1
2
3
4
5
6
7
8
9
10

• 反斜杠 \ 可以用做转义符；
• 使用 r 可以让反斜杠不发生转义；

# !/usr/bin/python3

# 若输出D:Download\note\notebook，可以使用反斜杠\转译
print('D:Download\\note\\notebook')
# 若输出D:Download\note\notebook，还可以在字符串前添加r或R
print(r'D:Download\note\notebook')
1
2
3
4
5
6

• 字符串的截取的语法格式：变量[头下标:尾下标:步长]
  Python 没有单独的字符类型，一个字符就是长度为 1 的字符串；
  Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始；
• 字符串可以用 + 运算符连接在一起；
• 字符串可以用 * 运算符重复；

#!/usr/bin/python3

str='Hello world,你好 世界'

# 获取第1个字符
print(str[0])
# 获取第7个字符
print(str[6])

# 负数：获取倒数第一个字符
print(str[-1])    # 界
# 负数：获取倒数第二个字符
print(str[-2])    # 世

# 输出从第3个到第5个的字符
print(str[2:5])
# 输出从第3个开始后面所有的字符
print(str[2:])
# 输出从第2个到第5个且每隔一个的字符（步长为2）
print(str[1:5:2])

# 字符串重复：输出字符串两次
print(str * 2)

# 字符串连接：连接字符串
print(str + ' 你好')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

• in 、not in 判断字符串的包含关系：

in 、not in 判断字符串的包含关系：

#!/usr/bin/python3

a='hello'
b='hello world'

# 判断 b 中是否包含 a 
print(a in b)
# 判断 b 中是否包含 a 
print(a not in b)
1
2
3
4
5
6
7
8
9
10
11

• upper() 字母大写

#!/usr/bin/python3

a='hello World'
# 字母大写：输出 HELLO WORLD
print(a.upper())
1
2
3
4
5

• lower() 字母小写

#!/usr/bin/python3

a='hELLO WORLD'
# 字母小写：输出 hello world
print(a.lower())
1
2
3
4
5

• capitalize() 首字母转大写、其他字母小写

#!/usr/bin/python3

a='hELLO WORLD 12345'
# 首字母转大写、其他字母小写：输出：Hello world 12345
print(a.capitalize())
1
2
3
4
5

• title() 每个单词的首字母大写

#!/usr/bin/python3

a='this is an apple'
# 每个单词的首字母大写：输出 This Is An Apple
print(a.title())
1
2
3
4
5

• swapcase() 大写转小写,小写转大写

#!/usr/bin/python3

a='hELLO world'
# 大写转小写,小写转大写：输出 Hello WORLD
print(a.swapcase())
1
2
3
4
5

• startswith 判断是否以某个字符串开头

#!/usr/bin/python3

a='Hello world'
# 判断是否以'Hello'开头
print(a.startswith('Hello'))
1
2
3
4
5

• endswith 判断是否以某个字符串结束

#!/usr/bin/python3

a='Hello world'
# 判断是否以'world'结尾
print(a.endswith('world'))
1
2
3
4
5

• count() 统计字符串中字符出现的次数

#!/usr/bin/python3

a='Hello worLd'

# l 在字符串中出现的次数
print(a.count('l'))
# l 在字符串0-5之前出现的次数
print(a.count('l',0,5))
1
2
3
4
5
6
7
8

• strip() 删除前后空格或移除前后给定字符

#!/usr/bin/python3
a=' Hello world '

# 删除前后空格
print(a.strip())

# 移除给定字符
print(a.strip('Hd'))
1
2
3
4
5
6
7
8

• replace() 替换给定字符

#!/usr/bin/python3

a='Hello world'
# 替换给定字符：将world替换为python
print(a.replace('world','python'))
1
2
3
4
5

• find() 查找字符在字符串中的位置

#!/usr/bin/python3

a='Hello world'
# 查找'world'在字符串中的位置
print(a.find('world'))

# 如果查找不到在则返回-1
print(a.find('Worlds'))
1
2
3
4
5
6
7
8

2.3 List 列表

List（列表）是 Python 中使用最频繁的数据类型，列表可以完成大多数集合类的数据结构实现。

• 列表写在方括号 [] 之间、用逗号分隔开；
• 列表中元素的类型可以不相同，支持数字、字符串、甚至可以包含列表（所谓嵌套）。
• 列表与字符串一样，可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
  列表截取的语法格式：变量[头下标:尾下标]

#!/usr/bin/python3

list01 = [ 'a', 123 , 2.23, 'xia', 456 ]
list02 = [123, 'xia']

print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表
1
2
3
4
5
6
7
8
9
10
11

以上举例中：

• 加号 + 是列表连接运算符；
• 星号 * 是重复操作；

#!/usr/bin/python3

# 遍历list
list01 = [2, 3, 4]
for value in list01:
    print(value)

# 遍历list
list02 = [2, 3, 4]
for index in range(len(list02)):
    print(index,list02[index])

1
2
3
4
5
6
7
8
9
10
11
12

2.4 Tuple 元组

元组（Tuple）与列表类似，不同之处在于元组的元素不能修改。

• 元组写在小括号 () 里，元素之间用逗号隔开；
• 元组中元素的类型可以不相同，支持数字、字符串、甚至可以包含列表。
• 元组与字符串一样，可以被索引和截取，列表被截取后返回一个包含所需元素的新元组。

可以把字符串看作一种特殊的元组，虽然 Tuple 的元素不可改变，但它可以包含可变的对象，比如 list 列表。

#!/usr/bin/python3

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
tup3 = (1, 2, 3, 4, 5, 6)

print(tup3[0])  # 结果：1
print(tup3[1:5])  # 结果：(2, 3, 4, 5)
1
2
3
4
5
6
7
8

2.5 Set 集合

• 创建集合：
  可以使用大括号 { } 或者 set() 函数创建集合；
• 创建空集合：
  创建一个空集合必须用 set()而不是 { }，因为 { } 是用来创建一个空字典；
• 集合中不允许存在重复元素：
  集合中若插入重复元素，重复元素会被自动去掉；
• 集合与或非运算：
  使用-求集合的差集，使用|求集合的并集，使用&求集合的交集，使用^求两个集合不同时存在的元素。

#!/usr/bin/python3
# 创建集合：可以使用大括号 { } 或者 set() 函数创建集合
# 创建集合：重复的元素被自动去掉
set01 = {'a', 'b', 'c', 'a', 'b', 'c', 'd'}
set02 = set('abcdabcd')
# 创建空集合：创建一个空集合必须用 set()
set03 = set()
print(set01)
print(set02)
print(set03)
# 成员测试
if 'a' in set01:
    print('a 在集合中')
else:
    print('a 不在集合中')

# set可以进行集合运算
setA = set('abcdabcd')
setB = set('abcabc')
# 集合与或非
print(setA - setB)  # A 和 B 的差集
print(setA | setB)  # A 和 B 的并集
print(setA & setB)  # A 和 B 的交集
print(setA ^ setB)  # A 和 B 中不同时存在的元素
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2.6 Dictionary 字典

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

• 字典当中的元素是通过键来存取；
• 在同一个字典中 键(key) 必须是唯一；

#!/usr/bin/python3

# 创建一个空字典
dict01 = {}
dict01['01_key'] = "01_value"
dict01[2] = "02_value"
print("dict01['01_key']：", dict01['01_key'])  # 输出键为 '01_key' 的值
print("dict01[2]：", dict01[2])  # 输出键为 2 的值
# 创建字典
dict02 = {'01_key': '01_value', '02_key': 1, '03_key': '03_value'}
print("dict02：", dict02)  # 输出完整的字典
print("keys：", dict02.keys())  # 输出所有键
print("values：", dict02.values())  # 输出所有值
1
2
3
4
5
6
7
8
9
10
11
12
13

三、数据类型转换

Python 数据类型转换可以分为两种：

• 隐式类型转换：自动完成
• 显式类型转换：需要使用类型函数来转换

3.1 隐式类型转换

# !/usr/bin/python3  
  
num_int = 123  
num_float = 1.23  
num_new = num_int + num_float  
  
print("num_int：",num_int)  
print("num_int type：",type(num_int))  
  
print("num_float：",num_float)  
print("num_float type：", type(num_float))  
  
print("num_new：",num_new)  
print("num_new type:",type(num_new))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.2 显式类型转换

显式类型转换

在显式类型转换中，用户将对象的数据类型转换为所需的数据类型：使用 int()、float()、str() 等预定义函数来执行显式类型转换。

int() 转换为整型：

# !/usr/bin/python3  
  
x = int(1)   # x 输出结果为 1
y = int(2.8) # y 输出结果为 2
z = int("3") # z 输出结果为 3
1
2
3
4
5

float() 转换为浮点型：

# !/usr/bin/python3  
  
x = float(1)     # x 输出结果为 1.0
y = float(2.8)   # y 输出结果为 2.8
z = float("3")   # z 输出结果为 3.0
w = float("4.2") # w 输出结果为 4.2
1
2
3
4
5
6

str() 转换为字符串：

x = str("s1") # x 输出结果为 's1'
y = str(2)    # y 输出结果为 '2'
z = str(3.0)  # z 输出结果为 '3.0'
1
2
3

四、条件与循环控制

• if 语句
• while 循环

4.1 if 语句

• if语句的关键字为：if – elif – else；
• 每个条件后面要使用冒号 : 表示接下来是满足条件后要执行的语句块；
• 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块；

#!/usr/bin/python3
 
age = 18
if age <= 0:
    print("你是在逗我吧!")
elif age <=2:
    print("婴儿宝宝")
elif age < 18:
    print("未成年")
else:
    print("成年")
1
2
3
4
5
6
7
8
9
10
11

4.2 while 循环

• Python中没有do..while循环，在Python中while语句的一般形式是：

#!/usr/bin/python3

i = 1
while i<=100:
	print(i)
	i += 1
1
2
3
4
5
6

• Python中while搭配else使用时：如果while后面的条件语句为false时，则执行else的语句块的内容。

#!/usr/bin/python3

i = 1
while i<=100:
	print(i)
	i += 1
else:
   	print("end：",i)
1
2
3
4
5
6
7
8

4.3 for 循环

• Python for 循环可以遍历任何可迭代对象，格式为for <variable> in <sequence>

#!/usr/bin/python3  
  
# 构建array列表  
arrayList = ["a", "b", "c", "d"]  
for content in arrayList:  
    if content == "a":  
        print("if判断 a continue：", content)  
        continue  
 if content == "d":  
        print("if判断 d break：", content)  
        break  
 print("打印循环内容：" + content)  
else:  
    print("没有循环数据")  
print("完成循环")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• Python 如果需要遍历数字序列，可以使用内置range()函数。

#!/usr/bin/python3

for i in range(5):
    print(i)
1
2
3
4

五、迭代器与生成器

• 迭代器
• 生成器

5.1 迭代器

Python中迭代器是访问集合元素的一种方式，有两个基本的方法iter() 和 next()；

• 字符串、列表、元组都可创建迭代器；

# encoding: utf-8  
  
arry_list = [1, 2, 3, 4]  
# 创建迭代器对象  
iter01 = iter(arry_list)  
# 输出迭代器的下一个元素  
print("next: ", next(iter01))  
  
# for循环遍历迭代器  
for content in iter01:  
    print("循环: ", content)
1
2
3
4
5
6
7
8
9
10
11

5.2 生成器

Python中生成器是迭代器的一种，使用yield返回值函数，每次调用yield会暂停，而可以使用next()函数恢复生成器。

生成器类似于返回值为数组的一个函数：

• 这个函数可以接收参数与被调用，但是不同于一般的函数会一次性返回包括了所有数值的数组，生成器一次只能产生一个值，从而减少内存消耗。因此生成器看起来像是一个函数，但是表现却是迭代器。
• 一般在迭代一组数据时（以 list 容器为例），须先将所有数据存储到容器中，才能开始迭代；而生成器却不同，它可以实现在迭代的同时生成元素，对于可以用某种算法推算得到的多个数据，生成器并不会一次性生成它们，而是什么时候需要，才什么时候生成。

创建迭代器方式比较简单，大体分为以下 2 步：

• 定义一个以 yield 关键字标识返回值的函数；
• 调用刚刚创建的函数，即可创建一个生成器。

# encoding: utf-8

# 定义一个以 yield 关键字标识返回值的函数
def intNum():
    print("--- intNum start ---")
    for index in range(5):
        print("开始循环: ", index)
        yield index
        print("继续循环: ", index)
    print("--- intNum end ---")


# 调用函数，创建生成器
num = intNum()
# 调用 next() 内置函数
# print(next(num))
# 通过for循环遍历生成器
for i in num:
    print("遍历生成器：", i)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

六、Python3 函数

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()；
• 任何传入参数和自变量必须放在圆括号()中间，圆括号之间可以用于定义参数；
• 函数内容以冒号 : 起始，并且缩进；
• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

#!/usr/bin/python3  
  
# 定义一个比较函数  
def max(a, b):  
    if a > b:  
        return a  
    else:  
        return b  
  
  
print("比较结果:", max(4, 5))
1
2
3
4
5
6
7
8
9
10
11