Hexo

点滴积累 豁达处之

0%

python基础

Posted on Edited on In
python

python笔记

基础语法

行和缩进

​ Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。

缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。

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

多行语句

Python语句中一般以新行作为语句的结束符。

但是我们可以使用斜杠（ \）将一行的语句分为多行显示，如下所示：

1
2
3
total = item_one + \
        item_two + \
        item_three

语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例：

1
2
days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

引号

Python 可以使用引号( ‘ )、双引号( “ )、三引号( ‘’’ 或 “”” ) 来表示字符串，引号的开始与结束必须是相同类型的。

其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。

1
2
3
4
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""

注释

python中单行注释采用 # 开头。

1
2
# 第一个注释
print ("Hello, Python!")  # 第二个注释

python 中多行注释使用三个单引号 ‘’’ 或三个双引号 “””。

1
2
3
4
5
6
7
8
9
10
11
'''
这是多行注释，使用单引号。
这是多行注释，使用单引号。
这是多行注释，使用单引号。
'''

"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""

等待用户输入

1
2
prosson = input("请输入：")
   print(prosson)

同一行显示多条语句

Python可以在同一行中使用多条语句，语句之间使用分号(;)分割，以下是一个简单的实例：

1
2
3
#!/usr/bin/python

import sys; x = 'runoob'; sys.stdout.write(x + '\n')

输出

加号拼接（针对字符串）

1
2
3
4
str1 = "27.56"
    float1 = 27.56
    print("数据为：" + str1)
    print("数据为：" + str(float1))

format格式

1
2
3
4
5
6
a = 27.56
   b = 28.99
   c = 29.66
   print("数据为：{}".format(b))
   print("abc的数据分别为：{0}，{1}，{2}".format(a, b, c))
   print("abc的数据分别为：{1}，{0}，{2}".format(a, b, c))
1
2
3
4
5
a = 27.56
    b = 28.99
    c = 29.66
    print(f"数据为：{a}")
    print(f"abc的数据分别为：{a}，{b}，{c}")

输出百分比方法

1
2
3
4
d = 29.6666
   print('数据为：%.0f%%' % (d))
   print('数据为：%.1f%%' % (d))
   print('数据为：%.2f%%' % (d))

格式化输出

字符 含有
%s 字符串
%d 有符号十进制整数，%06d表示输出的整数显示位数字，不足的地方使用0补全
%f 浮点数，%.02f表示小数点后只显示两位
%% 输出%

%s:代表字符串的占位 %d:整型的占位

1
2
3
4
5
6
7
name = 'wan'
    age = 26
    print('%s的年龄是%d' % (name, age))
    age = 26.68
    print('%s的年龄是%d' % (name, age))
    age = "26"
    print('%s的年龄是%s' % (name, age))

%f浮点型

1
2
3
4
5
6
7
name = 'wan'
   money = 8000
   print('%s的工资为%f' % (name, money))
   money = 8000.687
   print('%s的工资为%0.1f' % (name, money))
   money = 8000.687
   print('%s的工资为%0.2f' % (name, money))

%%：输出%

1
2
d = 29
    print('数据为：%.0f%%' % (d))

不换行输出

一般情况下执行完print后，会自动换行，

1
2
3
4
5
6
7
8
第一种方法：
print('你需要输出的内容',end='')
    # print函数是将end参数默认设置为了’\n’，所以直接使用print函数会自动换行。
第二种方法：
调用模块sys，此处暂不讨论sys，仅仅列出简单的实现代码，如下代码会打印：abc123（无任何多余字符）
import sys
sys.stdout.write('abc')
sys.stdout.write('123')

变量类型

变量赋值

Python 中的变量赋值不需要类型声明。

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。

每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

等号 = 用来给变量赋值。

等号 = 运算符左边是一个变量名，等号 = 运算符右边是存储在变量中的值。例如：

1
2
3
4
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
print(counter)

多个变量赋值

Python允许你同时为多个变量赋值。例如：

1
a = b = c = 1

以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。

您也可以为多个对象指定多个变量。例如：

1
a, b, c = 1, 2, "john"

以上实例，两个整型对象 1 和 2 分别分配给变量 a 和 b，字符串对象 “john” 分配给变量 c。

数据类型

在内存中存储的数据可以有多种类型。

例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。

Python 定义了一些标准类型，用于存储各种类型的数据。

Python有五个标准的数据类型：

  • Numbers（数字）
  • String（字符串）
  • List（列表）
  • Tuple（元组）
  • Dictionary（字典）
1
2
num = 1
   print(type(num))

数字

数字数据类型用于存储数值。

他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。

当你指定一个值时，Number 对象就会被创建：

1
2
var1 = 1
   var2 = 1

可以使用del语句删除一些对象的引用。

1
2
del var
del var_a, var_b

Python支持四种不同的数字类型：

  • int（有符号整型）
  • long（长整型，也可以代表八进制和十六进制）
  • float（浮点型）
  • complex（复数）
math 模块、cmath 模块

Python 中数学运算常用的函数基本都在 math 模块、cmath 模块中。

Python math 模块提供了许多对浮点数的数学运算函数。

Python cmath 模块包含了一些用于复数运算的函数。

cmath 模块的函数跟 math 模块函数基本一致，区别是 cmath 模块运算的是复数，math 模块运算的是数学运算。

要使用 math 或 cmath 函数必须先导入：

1
import math
随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：

函数 描述
choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop ,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
random() 随机生成下一个实数，它在[0,1)范围内。
seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst) 将序列的所有元素随机排序
uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。

字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符。

python的字串列表有2种取值顺序:

  • 从左到右索引默认0开始的，最大范围是字符串长度少1
  • 从右到左索引默认-1开始的，最大范围是字符串开头

python_base01

如果你要实现从字符串中获取一段子字符串的话，可以使用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。

[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。

1
2
s = 'abcdef'
   print(s[1:5])

当使用以冒号分隔的字符串，python 返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界。

上面的结果包含了 s[1] 的值 b，而取到的最大范围不包括尾下标，就是 s[5] 的值 f。

python_base02

*加号（+）是字符串连接运算符，星号（）是重复操作。如下实例：**

1
2
3
4
5
6
7
str = 'Hello World!'
    print(str)            # 输出完整字符串
    print(str[0])         # 输出字符串中的第一个字符
    print(str[2:5])      # 输出字符串中第三个至第六个之间的字符串
    print(str[2:])        # 输出从第三个字符开始的字符串
    print(str * 2)        # 输出字符串两次
    print(str + "TEST")  # 输出连接的字符串

Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：

python_base03

1
2
str = 'abcdefg'
    print(str[1:4:2])   # bd
字符串常用方法

find: 检测某个子串是否包含在这个字符串中，如果在返回这个子串的位置下标， 否则返回-1

语法

1
字符串序列.find(子串， 开始位置下标， 结束位置下标)

注： 开始和结束位置下标可省略

1
2
mystr = "hello"
   print(mystr.find("el"))  # 1

index: 检测某个子串是否包含在这个字符串中，如果在返回这个子串的位置下标， 否则报错

1
2
mystr = "hello"
  print(mystr.index("ele"))  # substring not found

count: 返回某个子串在字符串中出现的次数

1
2
mystr = "hello"
  print(mystr.count("ele"))  # 0

split: 分隔，返回一个列表，丢失分隔字符

1
2
3
mystr = "hello and chen and java and python"
   print(mystr.split("and"))  # ['hello ', ' chen ', ' java ', ' python']
   print(mystr.split("and", 2))  # ['hello ', ' chen ', ' java and python']

join: 用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串

1
2
lsit1 = ["chuan", "zhi", "bo", "ke"]
  print("_".join(lsit1))  # chuan_zhi_bo_ke

isalpha : 判断字符串是否都为字母

isalpha : 判断字符串是否都为数字

isalnum : 判断字符串是否都为数字或字母

1
2
3
4
5
6
7
 mystr = "hello world and itcast and itheima and python"
 print(mystr.isalpha()) # False

# mystr = "6546543654"
 print(mystr.isdigit()) # False

 print(mystr.isalnum())  # False

列表

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。

列表用 [ ] 标识，是 python 最通用的复合数据类型。

列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

*加号 + 是列表连接运算符，星号 * 是重复操作。如下实例：*

1
2
3
4
5
6
7
8
9
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
   tinylist = [123, 'john']

   print(list)               # 输出完整列表     ['runoob', 786, 2.23, 'john', 70.2]
   print(list[0])            # 输出列表的第一个元素  runoob
   print(list[1:3])          # 输出第二个至第三个元素  [786, 2.23]
   print(list[2:])           # 输出从第三个开始至列表末尾的所有元素  [2.23, 'john', 70.2]
   print(tinylist * 2)       # 输出列表两次  [123, 'john', 123, 'john']
   print(list + tinylist)    # 打印组合的列表  ['runoob', 786, 2.23, 'john', 70.2, 123, 'john']
更新列表
1
2
3
4
list = []          ## 空列表
    list.append('Google')   ## 使用 append() 添加元素
    list.append('Runoob')
    print(list)  # ['Google', 'Runoob']
删除列表元素
1
2
3
4
5
list1 = ['physics', 'chemistry', 1997, 2000]
    print(list1) # ['physics', 'chemistry', 1997, 2000]
    del list1[2]
    print("After deleting value at index 2 : ")
    print(list1) # ['physics', 'chemistry', 2000]

元组

元组是另一个数据类型，类似于 List（列表）。

元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

1
2
3
4
5
6
7
8
9
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
   tinytuple = (123, 'john')

   print(tuple)               # 输出完整元组   ('runoob', 786, 2.23, 'john', 70.2)
   print(tuple[0])            # 输出元组的第一个元素    runoob
   print(tuple[1:3])          # 输出第二个至第四个（不包含）的元素  (786, 2.23)
   print(tuple[2:] )          # 输出从第三个开始至列表末尾的所有元素 (2.23, 'john', 70.2)
   print(tinytuple * 2 )      # 输出元组两次   (123, 'john', 123, 'john')
   print(tuple + tinytuple)   # 打印组合的元组  ('runoob', 786, 2.23, 'john', 70.2, 123, 'john')

注 元组不允许更新，列表是允许更新的：

1
2
3
4
5
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000    # 元组中是非法应用
list[2] = 1000     # 列表中是合法应用
元组是不允许更新的，所以以上代码执行错误，结果如下：
修改元组
1
2
3
4
5
6
7
8
9
tup1 = (12, 34.56)
    tup2 = ('abc', 'xyz')

    # 以下修改元组元素操作是非法的。
    # tup1[0] = 100
    
    # 创建一个新的元组
    tup3 = tup1 + tup2
    print(tup3) # (12, 34.56, 'abc', 'xyz')

字典

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用”{ }”标识。字典由索引(key)和它对应的值value组成。

1
2
3
4
5
6
7
8
9
10
11
dict = {}
    dict['one'] = "This is one"
    dict[2] = "This is two"
    tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}

    print(dict['one'])          # 输出键为'one' 的值   This is one
    print(dict[2])              # 输出键为 2 的值   This is two
    print(dict)              # 输出完整的字典  {'one': 'This is one', 2: 'This is two'}
    print(tinydict)             # 输出完整的字典  {'name': 'runoob', 'code': 6734, 'dept': 'sales'}
    print(tinydict.keys())      # 输出所有键  dict_keys(['name', 'code', 'dept'])
    print(tinydict.values())    # 输出所有值  dict_values(['runoob', 6734, 'sales'])
修改字典
1
2
3
4
5
6
7
tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

    tinydict['Age'] = 8 # 更新
    tinydict['School'] = "RUNOOB" # 添加

    print("tinydict['Age']: ", tinydict['Age']) # tinydict['Age']:  8
    print("tinydict['School']: ", tinydict['School']) # tinydict['School']:  RUNOOB
删除字典元素
1
2
3
4
5
tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

    del tinydict['Name']  # 删除键是'Name'的条目
    tinydict.clear()      # 清空字典所有条目
    del tinydict          # 删除字典

数据类型转换

函数 描述
int(x[,base]) 将x转换为一个整数
long(x[,base]) 将x转换为一个长整数
float(x[,base]) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
unichr(x) 将一个整数转换为Unicode字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct 将一个整数转换为一个八进制字符串

运算符

运算符分类

Python语言支持以下类型的运算符:

  • 算术运算符
  • 比较（关系）运算符
  • 赋值运算符
  • 逻辑运算符
  • 位运算符
  • 成员运算符
  • 身份运算符
  • 运算符优先级

逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符 逻辑表达式 描述 实例
and x and y 布尔”与” - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔”或” - 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔”非” - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
a = 10
 b = 20
if  a and b :
	print("1 - 变量 a 和 b 都为 true")
else:
	print("1 - 变量 a 和 b 有一个不为 true")
            
if  a or b :
    print("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
    print("2 - 变量 a 和 b 都不为 true")   
        
if not( a and b ):
    print("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
    print("5 - 变量 a 和 b 都为 true")
        
#1 - 变量 a 和 b 都为 true
#2 - 变量 a 和 b 都为 true，或其中一个变量为 true
#5 - 变量 a 和 b 都为 true

扩展

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a = 0
   b = 1
   c = 2
   # and 运算符，只要有一个值为0，则结果为0，否则结果为最后一个非0数字
   print(a and b) # 0
   print(b and a) # 0
   print(a and c) # 0
   print(c and a) # 0
   print(b and c) # 2
   print(c and b) # 1

   # or 运算符， 只有所有值为0结果才为0 否则结果为第一个非0的数字
   print(a and b) # 1
   print(a and c) # 2
   print(b and c) # 1

成员运算符

Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 a = 10
    b = 20
    list = [1, 2, 3, 4, 5 ];

    if ( a in list ):
        print("1 - 变量 a 在给定的列表中 list 中")
    else:
        print("1 - 变量 a 不在给定的列表中 list 中")

    if ( b not in list ):
        print("2 - 变量 b 不在给定的列表中 list 中")
    else:
        print("2 - 变量 b 在给定的列表中 list 中")

    # 修改变量 a 的值
    a = 2
    if ( a in list ):
        print("3 - 变量 a 在给定的列表中 list 中")
    else:
        print("3 - 变量 a 不在给定的列表中 list 中")
            
#1 - 变量 a 不在给定的列表中 list 中
#2 - 变量 b 不在给定的列表中 list 中
#3 - 变量 a 在给定的列表中 list 中

身份运算符

身份运算符用于比较两个对象的存储单元

运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 **id(a) != id(b)**。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注： id() 函数用于获取对象内存地址。

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
27
28
 a = 20
    b = 20

    if ( a is b ):
        print("1 - a 和 b 有相同的标识")
    else:
        print("1 - a 和 b 没有相同的标识")

    if ( a is not b ):
        print("2 - a 和 b 没有相同的标识")
    else:
        print("2 - a 和 b 有相同的标识")

    # 修改变量 b 的值
    b = 30
    if ( a is b ):
        print("3 - a 和 b 有相同的标识")
    else:
        print("3 - a 和 b 没有相同的标识")

    if ( a is not b ):
        print("4 - a 和 b 没有相同的标识")
    else:
        print("4 - a 和 b 有相同的标识")
#1 - a 和 b 有相同的标识
#2 - a 和 b 有相同的标识
#3 - a 和 b 没有相同的标识
#4 - a 和 b 没有相同的标识

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个(同一块内存空间)， == 用于判断引用变量的值是否相等。

1
2
3
4
5
6
7
a = [1, 2, 3]
    b = a
    print(b is a) # True
    print(b == a) # True
    b = a[:]
    print( b is a) # False
    print(b == a) # True

条件语句

if 语句用于控制程序的执行，基本形式为：

1
2
3
4
5
6
7
8
if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……
1
2
3
4
5
6
7
8
9
10
11
12
13
num = 5
  if num == 3:            # 判断num的值
      print('boss')
  elif num == 2:
      print('user')
  elif num == 1:
      print('worker')
  elif num < 0:           # 值小于零时输出
      print('error')
  else:
      print('roadman')     # 条件均不成立时输出
      
      # roadman

你也可以在同一行的位置上使用if条件判断语句，如下实例：

1
2
3
4
5
6
var = 100
    if ( var  == 100 ) : print("变量 var 的值为100")
    print("Good bye!")

   # 变量 var 的值为100
   # Good bye!

三目运算符

格式

1
exp1 if contion else exp2

循环语句

增强for循环

格式

1
2
for iterating_var in sequence:
   statements(s)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
for letter in 'Python':     # 第一个实例
        print("当前字母: %s" % letter)

    fruits = ['banana', 'apple',  'mango']
    for fruit in fruits:        # 第二个实例
        print ('当前水果: %s'% fruit)
    
    print ("Good bye!")
        
# 打印结果     
当前字母: P
当前字母: y
当前字母: t
当前字母: h
当前字母: o
当前字母: n
当前水果: banana
当前水果: apple
当前水果: mango
Good bye!

通过序列索引迭代

另外一种执行循环的遍历方式是通过索引，如下实例：

1
2
3
4
5
6
7
8
9
10
 fruits = ['banana', 'apple',  'mango']
    for index in range(len(fruits)):
        print ('当前水果 : %s' % fruits[index])

    print ("Good bye!")

# fruits = ['banana', 'apple',  'mango']
# for index in range(len(fruits)):
#    print ('当前水果 : %s' % fruits[index])
# print ("Good bye!")

循环使用 else 语句

for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
   for num in range(10,20):  # 迭代 10 到 20 之间的数字
        for i in range(2,num): # 根据因子迭代
            if num%i == 0:      # 确定第一个因子
                j=num/i          # 计算第二个因子
                print ('%d 等于 %d * %d' % (num,i,j))
                break            # 跳出当前循环
        else:                  # 循环的 else 部分
            print ('%d 是一个质数' % num)

#10 等于 2 * 5
11 是一个质数
12 等于 2 * 6
13 是一个质数
14 等于 2 * 7
15 等于 3 * 5
16 等于 2 * 8
17 是一个质数
18 等于 2 * 9
19 是一个质数

break continue 语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
   for letter in 'Python':     # 第一个实例
        if letter == 'h':
            break
        print('当前字母 :', letter)

    var = 10                    # 第二个实例
    while var > 0:
        print('当前变量值 :', var)
        var = var -1
        if var == 5:   # 当变量 var 等于 5 时退出循环
            break

    print("Good bye!")

打印
当前字母 : P
当前字母 : y
当前字母 : t
当前变量值 : 10
当前变量值 : 9
当前变量值 : 8
当前变量值 : 7
当前变量值 : 6
Good bye!
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
27
28
29
  for letter in 'Python':     # 第一个实例
        if letter == 'h':
            continue
        print('当前字母 :', letter)

    var = 10                    # 第二个实例
    while var > 0:
        var = var -1
        if var == 5:
            continue
        print('当前变量值 :', var)
    print("Good bye!")
    
    打印
    当前字母 : P
当前字母 : y
当前字母 : t
当前字母 : o
当前字母 : n
当前变量值 : 9
当前变量值 : 8
当前变量值 : 7
当前变量值 : 6
当前变量值 : 4
当前变量值 : 3
当前变量值 : 2
当前变量值 : 1
当前变量值 : 0
Good bye!

日期和时间

Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。

Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。

时间间隔是以秒为单位的浮点小数。

每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。

获取当前时间

1
2
localtime = time.localtime(time.time())
   print("本地时间为 :", localtime) # 本地时间为 : time.struct_time(tm_year=2022, tm_mon=5, tm_mday=9, tm_hour=15, tm_min=25, tm_sec=26, tm_wday=0, tm_yday=129, tm_isdst=0)

获取格式化的时间

1
2
localtime = time.asctime( time.localtime(time.time()) )
    print("本地时间为 :", localtime) # 本地时间为 : Mon May  9 15:26:39 2022

格式化日期

我们可以使用 time 模块的 strftime 方法来格式化日期，：

1
2
3
4
5
6
7
8
9
# 格式化成2016-03-20 11:45:39形式
   print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())) # 2022-05-09 15:29:24

   # 格式化成Sat Mar 28 22:24:24 2016形式
   print(time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())) # Mon May 09 15:29:24 2022
   
   # 将格式字符串转换为时间戳
   a = "Sat Mar 28 22:24:24 2016"
   print(time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))) # 1459175064.0

python中时间日期格式化符号：

  • %y 两位数的年份表示（00-99）
  • %Y 四位数的年份表示（000-9999）
  • %m 月份（01-12）
  • %d 月内中的一天（0-31）
  • %H 24小时制小时数（0-23）
  • %I 12小时制小时数（01-12）
  • %M 分钟数（00-59）
  • %S 秒（00-59）
  • %a 本地简化星期名称
  • %A 本地完整星期名称
  • %b 本地简化的月份名称
  • %B 本地完整的月份名称
  • %c 本地相应的日期表示和时间表示
  • %j 年内的一天（001-366）
  • %p 本地A.M.或P.M.的等价符
  • %U 一年中的星期数（00-53）星期天为星期的开始
  • %w 星期（0-6），星期天为星期的开始
  • %W 一年中的星期数（00-53）星期一为星期的开始
  • %x 本地相应的日期表示
  • %X 本地相应的时间表示
  • %Z 当前时区的名称
  • %% %号本身

获取某月日历

Calendar模块有很广泛的方法用来处理年历和月历，例如打印某月的月历：

1
2
3
4
5
6
7
8
9
10
11
12
13
 cal = calendar.month(2016, 1)
    print("以下输出2016年1月份的日历:")
    print(cal)


以下输出2016年1月份的日历:
    January 2016
Mo Tu We Th Fr Sa Su
             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 27 28 29 30 31

函数

函数定义

你可以定义一个由自己想要功能的函数，以下是简单的规则：

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

语法

1
2
3
4
def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

函数调用

1
2
3
4
5
def printme( str ):
        "打印传入的字符串到标准显示设备上"
        print(str)
        return
    printme("我要调用用户自定义函数!")

参数传递

在 python 中，类型属于对象，变量是没有类型的：

1
2
a=[1,2,3]
a="Runoob"

以上代码中，**[1,2,3]** 是 List 类型，**”Runoob”** 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

  • 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
  • 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

  • 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。

  • 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响

    python中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

传不可变对象实例

1
2
3
4
5
6
def ChangeInt( a ):
        a = 10

    b = 2
    ChangeInt(b)
    print(b)    # 结果是 2

实例中有 int 对象 2，指向它的变量是 b，在传递给 ChangeInt 函数时，按传值的方式复制了变量 b，a 和 b 都指向了同一个 Int 对象，在 a=10 时，则新生成一个 int 值对象 10，并让 a 指向它。

传可变对象实例

1
2
3
4
5
6
7
8
9
10
11
# 可写函数说明
   def changeme( mylist ):
       "修改传入的列表"
       mylist.append([1,2,3,4])
       print("函数内取值: ", mylist) # 函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
       return

   # 调用changeme函数
   mylist = [10,20,30]
   changeme( mylist )
   print("函数外取值: ", mylist) # 函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

参数

以下是调用函数时可使用的正式参数类型：

  • 必备参数
  • 关键字参数
  • 默认参数
  • 不定长参数

必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

调用printme()函数，你必须传入一个参数，不然会出现语法错误：

1
2
3
4
5
6
7
8
#可写函数说明
    def printme( str ):
        "打印任何传入的字符串"
        print(str)
        return

    #调用printme函数
    printme() # TypeError: printme() missing 1 required positional argument: 'str'

关键字参数

关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

以下实例在函数 printme() 调用时使用参数名：

1
2
3
4
5
6
7
8
#可写函数说明
   def printme( str ):
       "打印任何传入的字符串"
       print(str)
       return

   #调用printme函数
   printme( str = "My string") # My string

下例能将关键字参数顺序不重要展示得更清楚：

1
2
3
4
5
6
7
8
9
#可写函数说明
    def printinfo( name, age ):
        "打印任何传入的字符串"
        print("Name: ", name)  # Name:  miki
        print("Age ", age)  # Age  50
        return

    #调用printinfo函数
    printinfo( age=50, name="miki" )

默认参数

调用函数时，默认参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
  #可写函数说明
    def printinfo( name, age = 35 ):
        "打印任何传入的字符串"
        print("Name: ", name)
        print("Age ", age)
        return
    
    #调用printinfo函数
    printinfo( age=50, name="miki" )
    printinfo( name="miki" )
    
    打印
    Name:  miki
Age  50
Name:  miki
Age  35

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：

1
2
3
4
def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

加了星号（*）的变量名会存放所有未命名的变量参数。不定长参数实例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 可写函数说明
    def printinfo( arg1, *vartuple ):
        "打印任何传入的参数"
        print("输出: ")
        print(arg1)
        for var in vartuple:
            print(var)
        return

    # 调用printinfo 函数
    printinfo( 10 )
    printinfo( 70, 60, 50 )
    
    打印
    输出:
10
输出:
70
60
50

匿名函数

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

  • lambda只是一个表达式，函数体比def简单很多。

  • lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

  • lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

  • 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

    语法

1
lambda [arg1 [,arg2,.....argn]]:expression
1
2
3
4
5
6
# 可写函数说明
   sum = lambda arg1, arg2: arg1 + arg2

   # 调用sum函数
   print("相加后的值为 : ", sum( 10, 20 )) # 相加后的值为 :  30
   print("相加后的值为 : ", sum( 20, 20 )) # 相加后的值为 :  40

变量作用域

一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：

  • 全局变量
  • 局部变量

类

python中定义类使用class关键字，class后面紧接类名，类名通常是大写开头的单词(无类继承时类名后可以加括号也可以不加括号)

类的定义

1
2
3
4
class ClassName:
		语句1
		...
		语句n

实例对象

1
2
3
4
5
6
7
8
9
10
11
class MyClass:
        """定义一个MyClass类"""
        i = 12345

        def func(self):
            return 'hello world'


    my_class = MyClass()
    print(id(my_class)) #  2029611672800
    print(my_class.i)   # 12345

self 参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 class MyClass:
        """定义一个MyClass类"""
        i = 12345

        def func(self):
            print("self参数：",self)
            return 'hello world'

    a = MyClass()
    print("实例对象：",a)
    a.func()

    b = MyClass()
    print("实例对象：",b)
    b.func()

"""
实例对象： <__main__.MyClass object at 0x000002D29354E3C8>
self参数： <__main__.MyClass object at 0x000002D29354E3C8>
实例对象： <__main__.MyClass object at 0x000002D29354EFD0>
self参数： <__main__.MyClass object at 0x000002D29354EFD0>
"""

注：
由于类起到模板的作用，因此，可以在创建实例的时候，把我们认为必须绑定的属性强制填写进去(绑定实例变量)。这里就用到Python当中的一个内置方法__init__方法，例如在Student类时，把name、score等属性绑上去

1
2
3
4
5
6
7
8
9
class MyClass:
        def __init__(self, name, score):
            self.name = name
            self.score = score


    myclass = MyClass("chen", 99)
    print(myclass.name) #  chen
    print(myclass.score) # 99

__init__方法的第一参数永远是self，表示创建的当前类实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身

模块

Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

下例是个简单的模块 support.py：

1