python基础（day 1）

基础

基本语句

条件语句

在进行逻辑判断时，我们需要用到条件语句，Python 提供了 if、elif、else 来进行逻辑判断。格式如下所示：

if 判断条件1:
    执行语句1...
elif 判断条件2:    
    执行语句2...
elif 判断条件3:
    执行语句3...
else:    
    执行语句4...

循环语句

当需要多次重复执行时，我们要用到循环语句，Python 提供了 for 循环和 while 循环。

for 循环

for 循环可以遍历任何序列，比如：字符串。如下所示：

str = 'Python'
for s in str:    
    print(s)

输出结果：

P
y
t
h
o
n

while 循环

while 循环，满足条件时进行循环，不满足条件时退出循环。如下所示：

sum = 0
m = 10
while m > 0:
    sum = sum + m    
    m = m - 1
print(sum)

输出结果：

55

break

break 用在 for 循环和 while 循环语句中，用来终止整个循环。如下所示：

str = 'Python'
for s in str:    
    if s == 'o':       
        break  
print(s)

输出结果：

P
y
t
h

continue

continue 用在 for 循环和 while 循环语句中，用来终止本次循环。如下所示：

str = 'Python'
for s in str:    
    if s == 'o':        
        continue    
print(s)

输出结果：

P
y
t
h
o

pass 语句

pass 是空语句，它不做任何事情，一般用做占位语句，作用是保持程序结构的完整性。如下所示：

if True:    
	pass

数据类型

数值类型

三种数值类型，分别是：

整型（int）、

浮点型（float）、

复数（complex）

• 整型：包括正整数、负整数。如：1024、-1024。整型有四种进制表示，分别为：二进制、八进制、十进制、十六进制，说明如下表所示：

种类	描述	引导符
二进制	由 0 和 1 组成	0b 或 0B
八进制	由 0 到 7 组成	0o 或 0O
十进制	默认情况	无
十六进制	由 0 到 9、a 到 f、A 到 F 组成，不区分大小写	0x 或 0X

• 浮点型：由整数部分和小数部分组成。

• 复数：由实数部分和虚数部分组成。

基本运算

运算	描述
x + y	x 和 y 的和
x - y	x 和 y 的差
x * y	x 和 y 的乘积
x / y	x 和 y 的商
x // y	x 除以 y，取整除
x % y	x 除以 y，取模
-x	x 取反
+x	x 不变
abs(x)	x 的绝对值
int(x)	将 x 转换为整数
float(x)	将 x 转换为浮点数
complex(x, y)	一个带有实部 x 和虚部 y 的复数，y 默认为 0。
divmod(x, y)	(x // y, x % y)
pow(x, y)	x 的 y 次幂
x ** y	x 的 y 次幂

数学函数

除了上面的基本运算外，还可以借助数学模块 math 实现更多的运算。

首先要先引入数学模块 math。如下所示：

import math

引入之后就可以使用了，以 math 模块中求平方根函数 sqrt(x) 为例。使用方式如下所示：

import math
math.sqrt(1024)

math 模块中除了求平方根函数，还有很多可以使用的函数。如下表所示：

abs(x)	返回 x 的绝对值
ceil(x)	返回 x 的上入整数，如：math.ceil(1.1) 返回 2
floor(x)	返回 x 的下舍整数，如：math.floor(1.1) 返回 1
exp(x)	返回 e 的 x 次幂
log(x)	返回以 e 为底 x 的对数
log10(x)	返回以 10 为底 x 的对数
pow(x, y)	返回 x 的 y 次幂
sqrt(x)	返回 x 的平方根
factorial(x)	返回 x 的阶乘

随机函数

在安全领域有时会用到随机数，random 模块对随机数的生成提供了支持。

首先还是要引入 random 模块。如下所示：

import random

下面简单介绍两个函数：

random(x)函数

随机生成一个 0 到 1 范围内的实数。使用如下所示：

import random
random.random()

uniform(x, y)函数

随机生成一个 x 到 y 范围内的实数。使用如下所示：

import random
random.uniform(1,10)

字符串

基础操作

访问单个字符

s = 'Python'
# 访问第一个字符 P
print(s[0])

访问范围内字符

s = 'Python'
# 访问 yt
print(s[1:3])
# 访问 Pyt
print(s[:3])
# 访问 hon
print(s[3:])

单个字符编码

Python 使用了 ord() 函数返回单个字符的编码，chr() 函数把编码转成相应字符。如下所示：

s = 'A'
print(ord(s))
print(chr(65))

输出结果：

65
A

转义符

之前我们说过可以通过反斜杠 \ 将一行语句分多行显示，其实就是 \ 来转义字符，一些常见的转义字符如下表所示：

转义字符	描述
\	在行尾使用时，用作续行符
\b	退格（Backspace）
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车

运算符

运算符	描述
+	连接符
*	重复输出
[]	通过索引获取字符串中字符
[ : ]	获取字符串中的一部分
in	字符串中是否包含指定字符
not in	字符串中是否不包含指定字符
r/R	字符串原样输出

示例：

s1 = 'Hello'
s2 = 'Python'
print('s1 + s2 -->', s1 + s2)
print('s1 * 2 -->', s1 * 2)
print('s1[0] -->', s1[0])
print('s1[0:2] -->',s1[0:2])
print('"H" in s1 -->','H' in s1)
print('"H" not in s1 -->','H' not in s1)
print('\\r -->', R'\r')

输出结果：

s1 + s2 --> HelloPython
s1 * 2 --> HelloHello
s1[0] --> H
s1[0:2] --> He
"H" in s1 --> True
"H" not in s1 --> False
\r --> \r

当我们需要输出的内容中含有变量时，比如：Hello xxx，xxx 为变量，此时便需要一种格式化字符串的方式，Python 使用 % 格式化字符串，常用占位符如下表所示：

占位符	描述
%s	格式化字符串
%d	格式化整数
%f	格式化浮点数

以字符串为例，如下所示：

print('Hello %s' % 'Python')

输出结果：

Hello Python

我们也可以使用字符串的 format() 方法进行格式化，先看下示例：

print('{0} {1}'.format('Hello', 'Python'))

这种方式是用传入的参数依次替换字符串内的占位符{0}、{1} ...

序列

Python 中的序列是一块可存放多个值的连续内存空间，所有值按一定顺序排列，每个值所在位置都有一个编号，称其为索引，我们可以通过索引访问其对应值。

上一节字符串就是序列结构，除此之外常见的序列结构还包括列表、元组等。

索引

序列索引支持非负数和负数，索引为非负数，从 0 开始，如下所示：

索引为负数由右向左计数，从 -1 开始，如图所示：

下面通过一个示例作进一步了解，以字符串为例，如下所示：

str = 'Python'
print('str[0] str[-6] =', str[0], str[-6])
print('str[5] str[-1] =', str[5], str[-1])

输出结果：

str[0] str[-6] = P P
str[5] str[-1] = n n

从结果来看，我们使用非负数索引与负数索引得到的结果一致。

切片

切片操作可以访问一定范围内的元素，语法如下所示：

sname[start : end : step]

• sname：表示序列的名称；

• start：开始索引位置（包括该位置），默认为 0；

• end：表示切片的结束索引位置（不包括该位置），默认为序列的长度；

• step：步长。

以字符串为例，如下所示：

str = 'Python'
print(str[:3])
print(str[3:])
print(str[:])

输出结果：

Pyt
hon
Python

内置函数

函数	描述
len()	计算序列的长度
max()	找出序列中的最大元素
min()	找出序列中的最小元素
list()	将序列转换为列表
str()	将序列转换为字符串
sum()	计算元素的和
sorted()	对元素进行排序
enumerate()	将序列组合为一个索引序列，多用在 for 循环中

简单举几个例子，如下所示：

str = 'dbcae'
print('len -->', len(str))
print('max -->', max(str))
print('sorted -->', sorted(str))

输出结果：

len --> 5
max --> e
sorted --> ['a', 'b', 'c', 'd', 'e']

列表和元组

列表

Python 中没有数组，而是加入了功能更强大的列表（list），列表可以存储任何类型的数据，同一个列表中的数据类型还可以不同；列表是序列结构，可以进行序列结构的基本操作：索引、切片、加、乘、检查成员。

创建

列表中所有元素都放在一个中括号 [] 中，相邻元素之间用逗号 , 分隔，如下所示：

l = [1024, 0.5, 'Python']

访问

通过索引访问列表中的值，还可以使用 : 截取范围内的元素，如下所示：

l = [1024, 0.5, 'Python']
print('l[0] -->', l[0])
print('l[1:] -->', l[1:])

输出结果：

l[0] --> 1024
l[1:] --> [0.5, 'Python']

更新

除了对列表中现有元素进行修改外，还可以使用 append() 向列表中添加新元素，如下所示：

l = [1024, 0.5, 'Python']
# 修改列表中第二个元素
l[1] = 5
# 向列表中添加新元素
l.append('Hello')
print('l[1] -->', l[1])
print('l -->', l)

输出结果：

l[1] --> 5
l --> [1024, 5, 'Python', 'Hello']

删除

使用 del 删除列表中元素，如下所示：

l = [1024, 0.5, 'Python']
# 删除列表中第二个元素
del l[1]
print('l -->', l)

输出结果：

l --> [1024, 'Python']

常用方法

① count()

统计列表中某个元素出现的次数，使用如下所示：

l = ['d', 'b', 'a', 'f', 'd']
print("l.count('d') -->", l.count('d'))

输出结果：

l.count('d') --> 2

② index()

查找某个元素在列表中首次出现的位置（即索引），使用如下所示：

l = ['d', 'b', 'a', 'f', 'd']
print("l.index('d') -->", l.index('d'))

输出结果：

l.index('d') --> 0

③ remove()

移除列表中某个值的首次匹配项，使用如下所示：

l = ['d', 'b', 'a', 'f', 'd']
l.remove('d')
print("l -->", l)

输出结果：

l --> ['b', 'a', 'f', 'd']

④ sort()

对列表中元素进行排序，使用如下所示：

l = ['d', 'b', 'a', 'f', 'd']
l.sort()
print('l -->', l)

输出结果：

l --> ['a', 'b', 'd', 'd', 'f']

⑤ copy()

复制列表，使用如下所示：

l = ['d', 'b', 'a', 'f', 'd']
lc = l.copy()
print('lc -->', lc)

输出结果：

lc --> ['d', 'b', 'a', 'f', 'd']

元组

元组（tuple）与列表类似，但元组是不可变的，可简单将其看作是不可变的列表，元组常用于保存不可修改的内容。

创建

元组中所有元素都放在一个小括号 () 中，相邻元素之间用逗号 , 分隔，如下所示：

t = (1024, 0.5, 'Python')

访问

与访问列表中元素类似，如下所示：

t = (1024, 0.5, 'Python')
print('t[0] -->', t[0])
print('t[1:] -->', t[1:])

输出结果：

t[0] --> 1024
t[1:] --> (0.5, 'Python')

修改

元组中元素不能被修改，我们要用重新赋值的方式操作，如下所示：

t = (1024, 0.5, 'Python')
t = (1024, 0.5, 'Python', 'Hello')
print('t -->', t)

输出结果：

t --> (1024, 0.5, 'Python', 'Hello')

删除

元组中的元素不能被删除，我们只能删除整个元组，如下所示：

t = (1024, 0.5, 'Python')
del t
print('t -->', t)

输出结果：

NameError: name 't' is not defined

由于元组实例被删除，所以输出了异常信息。

常用方法

① len()

计算元组中元素个数，使用如下所示：

t = (1024, 0.5, 'Python')
print('len(t) -->', len(t))

输出结果：

len(t) --> 3

② max() 和 min()

返回元组中元素最大、最小值，使用如下所示：

t = ('d', 'b', 'a', 'f', 'd')
print('max(t) -->', max(t))
print('min(t) -->', min(t))

输出结果：

max(t) --> f
min(t) --> a

③ tuple()

将列表转换为元组，使用如下所示：

l = ['d', 'b', 'a', 'f', 'd']
t = tuple(l)
print('t -->', t)

输出结果：

t --> ('d', 'b', 'a', 'f', 'd')

字典与集合

字典

字典（dict）是 Python 的数据结构，以键-值（key-value）的方式存在的。

dict 拥有良好的查询速度，dict 中的值可以是任意 Python 对象，多次对一个 key 赋 value，后面的 value 会把前面的 value 覆盖。

字典的内容在花括号 {} 内，键-值（key-value）之间用冒号 : 分隔，键值对之间用逗号 , 分隔，比如创建字典 d，如下所示：

创建

d = {'name':'小明', 'age':'18'}
# 使用 dict 函数
# 方式一
l = [('name', '小明'), ('age', 18)]
d = dict(l)
# 方式二
d = dict(name='小明', age='18')
# 空字典
d = dict()
d = {}

访问

字典中的值通过 key 进行访问，如下所示：

d = dict(name='小明', age='18')
d['name']
'小明'
# 使用 get 方法
d.get('name')
'小明'

修改

修改操作，以修改 age 为例，如下所示：

d = dict(name='小明', age='18')
d['age'] = '20'
d['age']
'20'

清空集合，如下所示：

d = dict(name='小明', age='18')
d.clear()
d
{}

获取字典的长度，如下所示：

d = dict(name='小明', age='18')
len(d)
2

集合

集合（set）与字典相同均存储 key，但也只存储 key，因 key 不可重复，所以 set 的中的值不可重复，也是无序的。

集合使用花括号 {} 或者 set() 函数创建，如果创建空集合只能使用 set() 函数，以创建集合 s 为例，如下所示：

s = {'a', 'b', 'c'}
# 使用 set 函数
s = set(['a', 'b', 'c'])
# 空集合
s = set()

集合中重复的元素会被自动过滤掉，如下所示：

>>> s = {'a', 'a', 'b', 'c', 'c'}
>>> s{'a', 'c', 'b'}

添加元素可以使用 add 或 update 方法，如果元素已经存在，则不进行操作，如下所示：

>>> s = {'a', 'b', 'c'}
>>> s.add('d')
>>> s{'a', 'd', 'c', 'b'}
>>> s.update('e')
>>> s{'a', 'b', 'e', 'd', 'c'}
# 添加已经存在的元素 
a>>> s.add('a')
>>> s{'a', 'b', 'e', 'd', 'c'}

删除元素使用 remove 方法，如下所示：

>>> s = {'a', 'b', 'c'}
>>> s.remove('c')
>>> s{'a', 'b'}

清空集合使用 clear 方法，如下所示：

>>> s = {'a', 'b', 'c'}
>>> s.clear()
>>> s
set()

获取集合的长度，同样使用 len 方法，如下所示：

>>> s = {'a', 'b', 'c'}
>>> len(s)
3

函数

简单来说函数就是一段实现特定功能的代码，使用函数可以提高代码的重复利用率。Python 中有很多内置函数，比如之前常用的 print 函数，当内置函数不足以满足我们的需求时，我们还可以自定义函数。

自定义函数

Python 使用 def 关键字来声明函数，格式如下所示：

def 函数名(参数):
    函数体
    return 返回值

如果要定义一个无任何功能的空函数，函数体只写 pass 即可。格式如下所示：

def 函数名():
	pass

当我们不确定参数的个数时，可以使用不定长参数，在参数名前加 * 进行声明，格式如下所示：

def 函数名(*参数名):
    函数体

我们还可以使用 lambda 定义匿名函数，格式如下所示：

lambda 参数 : 
	表达式

# 空函数
def my_empty():
    pass
# 无返回值
def my_print(name):
	print('Hello', name)
# 有返回值
def my_sum(x, y):
    s = x + y
    print('s-->', s)
    return s    
# 不定长参数
def my_variable(*params):
    for p in params:
        print(p)
# 匿名函数
my_sub = lambda x, y: x - y

面向对象

面向对象（OOP）是一种对现实世界理解和抽象的方法，对象的含义是指在现实生活中能够看得见摸得着的具体事物，一句比较经典的描述是一切皆对象，Python 是一门面向对象的语言，面向对象编程简单来说就是一种封装代码的方式。

面向对象相关概念

• 类：描述具有相同属性和方法的集合，简单来说就是一个模板，通它来创建对象。

• 对象：类的实例。

• 方法：类中定义的函数。

• 类变量：定义在类中且在函数之外的变量，在所有实例化对象中公用。

• 局部变量：方法中定义的变量，只作用于当前实例。

面向对象三大特性

• 封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，提高复用性和安全性。

• 继承：一个类继承一个基类便可拥有基类的属性和方法，可提高代码的复用性。

• 多态：父类定义的引用变量可以指向子类的实例对象，提高了程序的拓展性。

类

Python 中类的定义使用 class 关键字，语法如下所示：

class 类名:
	属性	...	
	方法	...

比如我们定义一个类 Cat，如下所示：

class Cat:	
    # 属性    
    color = 'black'    
    # 构造方法    
    def __init__(self, name):        
        self.name = name    
    # 自定义方法    
    def eat(self, food):        
        self.food = food       
        print(self.name, '正在吃'+food)

构造方法 __init__() 会在类实例化时自动调用。无论构造方法还是其他方法都需要将 self 作为第一个参数，它代表类的实例。

类创建好后，我们可以直接通过类名访问属性，格式为：类名.属性名，比如我们访问 Cat 类的 color 属性，如下所示：

print('color-->', Cat.color)

上面 Cat 类中定义的属性和方法都是公开的，除此之外我们还可以定义私有属性和方法，声明方式为：在属性名或方法名前加两条下划线，示例如下所示：

class Cat:
	__cid = '1'    
	def __run(self):        
		pass

需要强调一点是：外部不能访问私有属性和调用私有方法，自然 Cat.__cid 是会报错的。

对象

创建对象也称类的实例化，比如我们通过 Cat 类创建对象，如下所示：

 # 创建对象
 c = Cat('Tom')

创建好对象后，我们就可以使用它访问属性和调用方法了，如下所示：

# 访问属性
print('name-->', c.name)
print('color-->', c.color)
# 调用方法
c.eat('鱼')

同样对象 c 不能访问私有属性 __cid 及调用私有方法 __run，那我们会有这样一个疑问，这个私有属性和方法难道定义了却不能用吗？