Python基本用法

python学习日记

python简单实例

一、标准数据类型

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

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

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

Python 3 有六个标准的数据类型

  1. Numbers（数字）
  2. String（字符串）
  3. List（列表）
  4. Tuple（元组）
  5. Set ( 集合 )
  6. Dictionary（字典）

Python数字

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

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

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

var1=1
var2=10

还有del语法

del var1[,var2[,var3[....,varN]]]

QQ截图20220529234744

如上图是删除单个元素的，如果print（var1）就会报错。

删除完这个元素就不存在了。

还可以使用del语句删除单个或多个对象的引用

del vardel var_a, var_b

QQ截图20220530000140

就像前面的一样，简单理解就是删除就没有了。

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

  • int (有符号整型 )

  • float ( 浮点型 )

  • bool ( 布尔 )

  • complex ( 复数 )

    各种数字类型范例

    int（整数） float（浮点型） complex（复数）
    10 0.0 3.14j
    100 15.20 45.j
    -786 -21.9 9.322e-36j
    080 32.3+e18 .876j
    -0490 -90. -.6545+0J
    -0x260 -32.54e100 3e+26J
    0x69 70.2-E12 4.53e-7j

round(_,x)表示这个数字类型的”__“保留x位数。

Python 3 字符串

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

一般记为

s = "a1a2···an" (n>=0)

字符串通常用于表示文本常见的数据

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

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

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

s='I love study'
print(s[2:6])
print(s[0])

需要注意的是，s[2:6]中2是字符的开始，6是字符的结束，还有就是默认的第一个字符是从0开始的,其中的“：”是用来分割首尾；当定义的字符串中含有空格时，空格也是一个字符，想要输出love就应该如图所写。

在python中字符串是可以相加的：

print(s[0]+s[2:6])

如果是

print(s[2:])

意思是输出第三个字符后面所有的字符。

print(s*2)

这个意思是s这个字符串输出两遍。

Python 列表

列表 ( list ) 是 Python 中使用最频繁的数据类型

列表可以完成大多数集合类的数据结构实现

列表支持字符，数字，字符串甚至可以包含列表 ( 嵌套 )

列表用 [ ] 标识

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

同样列表可以使用加号 ( + ) 运算符连接两个列表 使用星号 (*) 是重复列表元素

list = [ 'python学习日记', 30 , 2022, 'python', 70.2 ]
tinylist = [123, 'python']

print (list)               # 输出完整列表
print (list[0])            # 输出列表的第一个元素
print (list[1:3])          # 输出第二个至第三个的元素 
print (list[2:])           # 输出从第三个开始至列表末尾的所有元素
print (tinylist * 2)       # 输出列表两次
print (list + tinylist)    # 打印组合的列表

需要注意的是输出的时候与字符串是有区别的

['python学习日记', 30, 2022, 'python', 70.2]
python学习日记
[30, 2022]
[2022, 'python', 70.2]
[123, 'python', 123, 'python']
['python学习日记', 30, 2022, 'python', 70.2, 123, 'python']

还有就是在列表中数字和字符是可以在一起的。

Python 元组

元组是另一个数据类型，类似于列表

元组用 () 标识，内部元素用逗号隔开

元组是不可变的，不能二次赋值，相当于只读列表

tuple = ( 'python学习日记', 2022 , 2.23, 'python', 70.2 )
tinytuple = (123, 'start')

print ( tuple )              # 输出完整元组
print ( tuple[0]  )          # 输出元组的第一个元素
print ( tuple[1:3] )         # 输出第二个至第三个的元素 
print ( tuple[2:] )          # 输出从第三个开始至列表末尾的所有元素
print ( tinytuple * 2 )      # 输出元组两次
print ( tuple + tinytuple )  # 打印组合的元组

输出的结果也是有元组标识的$\textcolor{red}{()}$ 

('python学习日记', 2022, 2.23, 'python', 70.2)
python学习日记
(2022, 2.23)
(2.23, 'python', 70.2)
(123, 'start', 123, 'start')
('python学习日记', 2022, 2.23, 'python', 70.2, 123, 'start')

$\textcolor{red}{注意：}$

元组是不允许更新的，像下面的表示就是错误的。

tuplo=('python学习日记'，2022)
tuplo[2]=2023#元组中是非法应用

set ( 集合 )

集合 (set ) 是一个无序不重复元素的序列

集合 (set ) 的基本作用是进行成员关系测试和删除重复元素

可以使用大括号 { } 或者 set() 函数创建集合

但要注意的是，创建一个空集合必须用 set() 而不是 { } ，因为 { } 是用来创建一个空字典

st={'python','study','PHP','字典'}
print(st)
'python' in st

QQ截图20220530211755

集合创造以后在输入一定条件后，python会自动判断。

集合是可以进行逻辑运算的：

QQ截图20220530212557

区别一下”列表、元组、集合“的表示：

列表用”[ ]“;

元组用”( )“;

集合用”{ }“;

Python 字典

字典 (dictionary) 是由键值对组成的集合，由键 (key) 和它对应的值 value 组成

列表是有序的对象结合，字典是无序的对象集合

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

字典用 { } 标识，可以使用 {} 创建，也可以使用 dict() 函数创建

dict={}
dict['one']="This is one"
dict[2]="This is two"

pythondict={'name':'guo','ID':'student','year':'2022'}

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

运行结果为：

This is one
This is two
{'name': 'guo', 'ID': 'student', 'year': '2022'}
dict_keys(['name', 'ID', 'year'])
dict_values(['guo', 'student', '2022'])
# ':'前面为key后面为values

Python 数据类型转换

有时候，我们需要将一种类型转换成另一种类型，比如将字符串 ‘3.1415926’ 转换成浮点型

这种过程，我们称之为 数据类型转换

Python 中，将一种类型转换成另一种类型非常简单，只需要数据类型作为函数名即可，比如

float('3.141596')

就能完成我们刚刚的需求了

下表列出了 Python 用于数据类型转换的函数

函数 描述
int(x [,base]) 将 x 转换为一个整数
float(x) 将 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(x) 将一个整数转换为一个八进制字符串

例如float型：

s='3.141596'
print(s)
print(type(s))
float(s)
print(float(s))
print(type(float(s)))
#输出结果

3.141596
<class 'str'>
3.141596
<class 'float'>

还有一些例子：

x='123'			#str型
print(x)
s=123			#int型
print(type(x))
int(x)
print(type(int(x)))
float(x)
print(type(float(x)))
complex(x)
print(complex(x))
print(type(complex(x)))
str(s)
print(type(s))
print(type(str(s)))
repr(s)
print(type(repr(s)))
tuple(x)			#元组
print(tuple(x))
print(type(tuple(x)))
list(x)				#列表
print(list(x))
print(type(list(x)))
set(x)				#集合
print(set(x))
print(type(set(x)))
#输出结果

123
<class 'str'>
<class 'int'>
<class 'float'>
(123+0j)
<class 'complex'>
<class 'int'>
<class 'str'>
<class 'str'>
('1', '2', '3')
<class 'tuple'>
['1', '2', '3']
<class 'list'>
{'3', '2', '1'}     #注意：这里集合是倒过来的
<class 'set'>

二、Python 3 注释

程序的注释是解释性语句，所有的编程语言都允许某种形式的注释

因此，注释就是为了增强源代码的可读性

Python 3 支持单行注释和多行注释

注释中的所有字符会被 Python 解释器忽略

Python中单行注释以 # 开头

# 这是一个注释
print("Hello, python!!!")

多行注释用三个单引号 ‘’’ 或者三个双引号 “”” 将注释括起来

1、单引号（’’’）

#!/usr/bin/python3 
'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号 
这是多行注释，用三个单引号
'''
print("Hello, python!!!")

2、双引号（”””）

#!/usr/bin/python3 
"""
这是多行注释，用三个单引号
这是多行注释，用三个单引号 
这是多行注释，用三个单引号
"""
print("Hello, python!!!")

三、Python 3 运算符

运算符是一种告诉编译器执行特定的数学或逻辑操作的符号

举个简单的例子 4 + 5 = 9

例子中， 4 和 5 被称为 操作数 ，” + “ 称为运算符

Python 支持以下几种运算符

python支持以下几种运算符：

1.算数运算符

2.比较（关系）运算符

3.赋值运算符

4.逻辑运算符

5.位运算符

6.成员运算符

7.身份运算符

8.运算符的优先级

1、python算数运算符

下表中，列出了 Python 支持的算术运算符

我们假定 a=10，b=2

运算符 描述 范例
+ 加 - 两个对象相加 a + b 输出结果 12
- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 8
* 乘 - 两个数相乘或重复若干次字符串 a * b 输出结果 20
/ 除 - x除以y b / a 输出结果 5.0
% 取模 - 返回除法的余数 b % a 输出结果 0
** 幂 - 返回x的y次幂 a**b 为 10 的 2 次方 输出结果 100
// 取整除 - 返回商的整数部分 9//2 输出结果 4 9.0//2.0 输出 4.0

例如：

a = 10
b = 2
c = 0

c = a + b
print ("1 - c 的值为：", c)

c = a - b
print ("2 - c 的值为：", c )

c = a * b
print ("3 - c 的值为：", c )

c = a / b
print ("4 - c 的值为：", c )

c = a % b
print ("5 - c 的值为：", c)

# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b 
print ("6 - c 的值为：", c)

a = 10
b = 5
c = a//b 
print ("7 - c 的值为：", c)
#结果

1 - c 的值为： 12
2 - c 的值为： 8
3 - c 的值为： 20
4 - c 的值为： 5.0
5 - c 的值为： 0
6 - c 的值为： 8
7 - c 的值为： 2

return

2、python比较运算符

所有比较运算符返回 1 表示真，返回 0 表示假

这分别与特殊的变量 True 和 False 等价。注意首字母为大写

下表列出了 Python 支持的比较运算符

我们假定 a=10，b=2

运算符 描述 范例
== 等于 - 比较对象是否相等 (a == b) 返回 False
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 true.
<> 不等于 - 比较两个对象是否不相等 (a <> b) 返回 true。类似 !=
> 大于 - 返回 x 是否大于y (a > b) 返回 True
< 小于 - 返回 x 是否小于y (a < b) 返回 False
>= 大于等于 - 返回 x 是否大于等于 y (a >= b) 返回 True
<= 小于等于 - 返回 x 是否小于等于 y (a <= b) 返回 False

例如：

a = 10
b = 2
c = 0

if ( a == b ):
   print ("1 - a 等于 b")
else:
   print ("1 - a 不等于 b")

if ( a != b ):
   print ("2 - a 不等于 b")
else:
   print ("2 - a 等于 b")


if ( a < b ):
   print ("4 - a 小于 b") 
else:
   print ("4 - a 大于等于 b")

if ( a > b ):
   print ("5 - a 大于 b")
else:
   print ("5 - a 小于等于 b")

# 修改变量 a 和 b 的值
a = 5
b = 20
if ( a <= b ):
   print ("6 - a 小于等于 b")
else:
   print ("6 - a 大于  b")

if ( b >= a ):
   print ("7 - b 大于等于 a")
else:
   print ("7 - b 小于 a")
#运算结果
1 - a 不等于 b
2 - a 不等于 b
4 - a 大于等于 b
5 - a 大于 b
6 - a 小于等于 b
7 - b 大于等于 a

return

3、python赋值运算符

下表列出了 Python 支持的赋值运算符

我们假定 a= 10 , b = 2

运算符 描述 范例
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c = a 等效于 c = c a
//= 取整除赋值运算符 c //= a 等效于 c = c // a

例如：

a = 10
b = 2
c = 0

c = a + b
print ("1 - c 的值为：", c)

c += a
print ("2 - c 的值为：", c )

c *= a
print ("3 - c 的值为：", c )

c /= a 
print ("4 - c 的值为：", c )

c = 2
c %= a
print ("5 - c 的值为：", c )

c **= a
print ("6 - c 的值为：", c )

c //= a
print ("7 - c 的值为：", c )#这里要注意这里的’//‘意思是除完一次以后取整
#需要注意的是 c 每进行一次赋值运算，其值也会进行改变
#运行结果

1 - c 的值为： 12
2 - c 的值为： 22
3 - c 的值为： 220
4 - c 的值为： 22.0
5 - c 的值为： 2
6 - c 的值为： 1024
7 - c 的值为： 102

return

4、python逻辑运算符

下表列出了 Python 语言支持逻辑运算符

我们假定 a = 10, b = 2

运算符 逻辑表达式 描述 范例
and x and y 布尔”与” - 如果 x 为 False，x and y 返回 False，否则返回 y 的计算值 (a and b) 返回 2
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 
a = 10
b = 2

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

# 修改变量 a 的值
a = 0
if ( a and b ):
   print ( "3 - 变量 a 和 b 都为 true" )
else:
   print ( "3 - 变量 a 和 b 有一个不为 true" )

if ( a or b ):
   print ( "4 - 变量 a 和 b 都为 true，或其中一个变量为 true" )
else:
   print ( "4 - 变量 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
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false

return

5、python位运算符

位运算符是把数字看作二进制来进行计算的

Python 中的位运算法则如下

下表中变量 a 为 60，b 为 13，二进制格式如下

a   = 0011 1100
b   = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a  = 1100 0011
运算符 描述 范例
& 按位与运算符 参与运算的两个值,如果两个相应位都为 1 则该位的结果为1,否则为0 (a & b) 输出结果 12 二进制 0000 1100
| 按位或运算符 只要对应的两个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 二进制 0011 1101
^ 按位异或运算符 当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 二进制 0011 0001
~ 按位取反运算符 对数据的每个二进制位取反 即把 1 变为0,把0变为1 ~x 类似于 -x-1 (~a ) 输出结果 -61 二进制 1100 0011 一个有符号二进制数的补码形式
<< 左移动运算符 运算数的各二进位全部左移若干位 由 “<<”右边的数指定移动的位数 高位丢弃，低位补0。 a << 2 输出结果 240 二进制 1111 0000
>> 右移动运算符 把”>>”左边的运算数的各二进位全部右移若干位 “>>”右边的数指定移动的位数 a >> 2 输出结果 15 二进制 0000 1111

例如：

a = 60            # 60 = 0011 1100 
b = 13            # 13 = 0000 1101 
c = 0

c = a & b;        # 12 = 0000 1100
print ( "1 - c 的值为：", c ) 

c = a | b;        # 61 = 0011 1101 
print ( "2 - c 的值为：", c )

c = a ^ b;        # 49 = 0011 0001
print ( "3 - c 的值为：", c )

c = ~a;           # -61 = 1100 0011
print ( "4 - c 的值为：", c )

c = a << 2;       # 240 = 1111 0000
print ( "5 - c 的值为：", c )

c = a >> 2;       # 15 = 0000 1111
print ( "6 - c 的值为：", c )
#运行结果
1 - c 的值为： 12
2 - c 的值为： 61
3 - c 的值为： 49
4 - c 的值为： -61
5 - c 的值为： 240
6 - c 的值为： 15

return

6、python成员运算符

Python 还支持成员运算符

范例中包含了一系列的成员，包括字符串，列表或元组

运算符 描述 范例
in 如果在指定的序列中找到值返回 True，否则返回 False 如果 x 在 y 序列中返回 True
not in 如果在指定的序列中没有找到值返回 True，否则返回 False 如果 x 不在 y 序列中返回 True

例如：

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 中

return

7、python身份运算符

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

运算符 描述 范例
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() 函数用于获取对象内存地址

a = 20
b = 20

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

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

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

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

if ( a is not b ):
   print ( "5 - a 和 b 没有相同的标识" )
else:
   print ( "5 - a 和 b 有相同的标识" )
#运行结果

1 - a 和 b 有相同的标识
2 - a 和 b 没有相同的标识
3 - a 和 b 有相同的标识
4 - a 和 b 没有相同的标识
5 - a 和 b 没有相同的标识

简单理解一下”成员运算符“与”身份运算符“的区别：

表面意思”成员运算符“是用来判断某个元素或集合是是否在这个集合或列表等中；”身份运算符“则是判断两个元素或集合是否相等或内存地址是否相同。

is与==的区别

is 用于判断两个变量引用对象是否为同一个

== 用于判断引用变量的值是否相等

例：
QQ截图20220531114742

a=[1,2,3]
b=a
if(b is a):
	print("yes")
if(b==a):
	print("yes")
b=a[:]
if(b is a):
	print("yes")
else:
	print("no")
if(b==a):
	print("yes")
#运行结果
yes
yes
no
yes

return

8、python运算符的优先级

下表列出了从最高到最低优先级的所有运算符

运算符 描述
** 指数 (最高优先级)
~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % // 乘，除，取模和取整除
+ - 加法减法
>> << 右移，左移运算符
& 位 ‘AND’
^ | 位运算符
<= < > >= 比较运算符
<> == != 等于运算符
= %= /= //= -= += = *= 赋值运算符
is is not 身份运算符
in not in 成员运算符
not or and 逻辑运算符

例：

a = 20
b = 10
c = 15
d = 5
e = 0

e = (a + b) * c / d       #( 30 * 15 ) / 5
print ( "(a + b) * c / d 运算结果为：",  e ) 

e = ((a + b) * c) / d     # (30 * 15 ) / 5
print ( "((a + b) * c) / d 运算结果为：",  e )

e = (a + b) * (c / d);    # (30) * (15/5)
print ( "(a + b) * (c / d) 运算结果为：",  e )

e = a + (b * c) / d;      #  20 + (150/5)
print ( "a + (b * c) / d 运算结果为：",  e 
#运行结果
       
(a + b) * c / d 运算结果为： 90.0
((a + b) * c) / d 运算结果为： 90.0
(a + b) * (c / d) 运算结果为： 90.0
a + (b * c) / d 运算结果为： 50.0

return

四、Python数学函数

导入模块

import math

下表列出了 Python math 模块提供的数学函数

函数 描述
abs(x) 返回数字的绝对值，如abs(-10) 返回 10
ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
operator.lt(x,y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,…) 返回给定参数的最大值，参数可以为序列
min(x1, x2,…) 返回给定参数的最小值，参数可以为序列
modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示
pow(x, y) xy 运算后的值
[round(x [,n])] 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数
sqrt(x) 返回数字x的平方根

五、Python 随机数函数

Python random 模块提供了许多的随机数生成函数

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

导入模块

import random

下表列出了 random 模块提供的随机数函数

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

六、Python math 模块中的三角函数

导入模块

import math

下表列出了 math 模块提供的三角函数

函数 描述
[math.acos(x)](./Python math 模块中的三角函数) 返回x的反余弦弧度值
[math.asin(x)](./Python math 模块中的三角函数) 返回x的反正弦弧度值
[math.atan(x)](./Python math 模块中的三角函数) 返回x的反正切弧度值
[math.atan2(y, x)](./Python math 模块中的三角函数) 返回给定的 X 及 Y 坐标值的反正切值
[math.cos(x)](./Python math 模块中的三角函数) 返回x的弧度的余弦值
[math.hypot(x, y)](./Python math 模块中的三角函数) 返回欧几里德范数 sqrt(xx + yy)
[math.sin(x)](./Python math 模块中的三角函数) 返回的x弧度的正弦值
[math.tan(x)](./Python math 模块中的三角函数) 返回x弧度的正切值
[math.degrees(x)](./Python math 模块中的三角函数) 将弧度转换为角度,如 degrees (math.pi/2) ， 返回 90.0
[math.radians(x)](./Python math 模块中的三角函数) 将角度转换为弧度

七、Python math 模块常量

导入模块

import math
常量 描述
math.pi 数学常量 pi ( 圆周率，一般以 π 来表示 )
math.e 数学常量 e，e 即自然常数（自然常数）

八、Python 3 字符串

字符串是 Python 中最常用的数据类型

Python 中可以有 4 中创建字符串的方法

  1. 使用单引号引起来

    >>> s1 = 'Hello \n World'
    >>> print (s1)
    Hello 
     World

  2. 使用双引号引起来的字符串

    >>> s1 = "Hello \n World"
    >>> print (s1)
    Hello 
     World

  3. 使用三个单引号引起来的字符串

    >>> s1 = '''Hello
    World

    Nice to see you
    '''
    >>> print (s1)
    Hello
    World

    Nice to see you

    >>>

  4. 使用三个单引号引起来的字符串

    >>> s1 = """Hello
    World

    Nice to see you
    """
    >>> print (s1)
    Hello
    World

    Nice to see you

    >>>

是不是很简单，创建字符串变量也是跟创建其它的变量一样

1、Python 访问字符串中的值

Python 可以使用下标索引访问字符串中单个字符

下标索引是一种特殊的访问方法，在变量后跟一对中括号，中括号里填入整形数字就能访问对应的元素

索引从 0 开始，第一个元素是 0 ，第二个元素是 1 … 以此类推

最后一个元素是 -1 ，倒数第二个元素是 -2 … 以此类推

>>> s1 = 'Hello Python'
>>> s1[1]
'e'
>>> s1[-2]
'o'

我们还可以使用下标索引来截取一段字符串

>>> s1 = 'Hello Python'
>>> s1[1:4]
'ell'
>>> s1[1:-1]
'ello Pytho'

2、Python 字符串更新

字符串本身是不能更改的，但可以使用下标索引将字符串中的一部分赋值给另一个字符串

>>> s1 = 'Hello Python'
>>> s1[3] = 'w'

Traceback (most recent call last):
  File "<pyshell#205>", line 1, in <module>
    s1[3] = 'w'
TypeError: 'str' object does not support item assignment
>>> s2 = s1[1:6]
>>> s2
'ello '

Python 转义字符

如果要在字符串中使用下表列出的特殊字符，就要使用 反斜杠( \ ) 转义字符

转义字符 描述
\ (在行尾时) 续行符
\ 反斜杠符号
' 单引号
" 双引号
\a 响铃
\b 退格(Backspace)
\e 转义
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\oyy 八进制数，yy代表的字符，例如：\o12代表换行
\xyy 十六进制数，yy代表的字符，例如：\x0a代表换行
\other 其它的字符以普通格式输出

3、Python 字符串运算符

下表列出了 Python 支持的字符串操作符

我们假定 a= “Hello”，b = “Python”

操作符 描述 范例
+ 字符串连接 >>>a+b ‘HelloPython’
* 重复输出字符串 >>>a*2 ‘HelloHello’
[] 通过索引获取字符串中字符 >>>a[1] ‘e’
[ : ] 截取字符串中的一部分 >>>a[1:4] ‘ell’
in 成员运算符 如果字符串中包含给定的字符返回 True >>>”H” in a True
not in 成员运算符 如果字符串中不包含给定的字符返回 True >>>”M” not in a True
r/R 原始字符串 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符 原始字符串除在字符串的第一个引号前加上字母”r”（可以大小写）以外，与普通字符串有着几乎完全相同的语法 >>>print (r’\n’) \n >>>print R’\n’ \n
% 格式字符串 情况后面介绍

下面的代码演示了这些运算符的使用

>>> a = 'Hello'
>>> b = 'Python'
>>> a+b
'HelloPython'
>>> a * 2
'HelloHello'
>>> a[1]
'e'
>>> a[1:4]
'ell'
>>> 'H' in a
True
>>> 'M' in a
False
>>> print (r'\n')
\n
>>> print (R'\n')
\n

九、Python 字符串格式化

Python 支持格式化字符串的输出

尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中

print('hello %s' %('world'))
hello world

1、格式化符

下表列出了 Python 支持的字符串格式化符号

格式化符 描述
%c 格式化字符及其 ASCII 码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址

2、格式化操作符辅助指令

符号 功能
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号 ( + )
在正数前面显示空格
# 在八进制数前面显示零 (‘0’) 在十六进制前面显示 ‘0x’ 或者 ‘0X’ ( 取决于用的是 ‘x’ 还是’X’)
0 显示的数字前面填充 ‘0’ 而不是默认的空格
% ‘%%’ 输出一个单一的 ‘%’
( var ) 映射变量(字典参数)
m.n. m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

3、str.format() 格式化字符串

Python 还内置了 format 用于格式化字符串，具体说明你可以直接点击链接查看

4、Python 三引号 ( triple quotes )

在本章的开始我们已经介绍过了 Python 可以使用三个引号来创建字符串

python 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其它的特殊字符

三引号的语法是一对连续的单引号或者双引号，通常都是成对的用

>>> s = '''Hello
World'''
>>> s            # repr()
'Hello\nWorld'
>>> print (s)      # str()
Hello
World

三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的 WYSIWYG ( 所见即所得 ) 格式的

一个典型的场景是，当需要一大块 HTML 或者 SQL 时，这时用字符串组合，特殊字符串转义将会非常的繁琐

errHTML = '''<!DOCTYPE html>
<meta charset="utf-8">
<title>Friends CGI Demo</title><
<h3>ERROR</h3>
<b>%s</b>
<form><input type="button" value="Back" 
onclick="window.history.back()"></form>
'''
cursor.execute('''
CREATE TABLE users (  
login VARCHAR(8), 
uid INTEGER,
prid INTEGER)
''')

5、Unicode 字符串

Python 3 中，所有的字符串都是 Unicode 字符串

>>> '你好'
'你好'
>>> type('你好')
<class 'str'>
>>> u'你好'
'你好'
>>> type(u'你好')
<class 'str'>

6、Python 字符串内建函数

下表列出了 Python 内建的字符串方法

方法 描述
string.capitalize() 把字符串的第一个字符大写
string.center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.decode(encoding=’UTF-8’, errors=’strict’) 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 ‘ignore’ 或 者’replace’
string.encode(encoding=’UTF-8’, errors=’strict’) 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8
string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.format() 格式化字符串
string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
string.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit() 如果 string 只包含数字则返回 True 否则返回 False.
string.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric() 如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace() 如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle() 如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.ljust(width) 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.lower() 转换 string 中所有大写字符为小写.
string.lstrip() 截掉 string 左边的空格
string.maketrans(frm, to) maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标
max(str) 返回字符串str中最大的字母
min(str) 返回字符串str中最小的字母
string.partition(str) 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.rfind(str, beg=0,end=len(string) ) 类似于 find()函数，不过是从右边开始查找.
string.rindex( str, beg=0,end=len(string)) 类似于 index()，不过是从右边开始.
string.rjust(width) 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.rpartition(str) 类似于 partition()函数,不过是从右边开始查找.
string.rstrip() 删除 string 字符串末尾的空格.
string.split(str=””, num=string.count(str)) 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
[string.splitlines(keepends]) 按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符
string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
[string.strip(obj]) 在 string 上执行 lstrip()和 rstrip()
string.swapcase() 翻转 string 中的大小写
string.title() 返回”标题化”的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.translate(str, del=””) 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
string.upper() 转换 string 中的小写字母为大写
string.zfill(width) 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0
string.isdecimal() isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于 unicode 对象