Python-基础知识

基础语法

Python 保留字符

下面的列表显示了在Python中的保留字。

这些保留字不能用作常数或变数，或任何其他标识符名称。

所有 Python 的关键字只包含小写字母。

and	exec	not
assert	finally	or
break	for	pass
class	from	print
continue	global	raise
def	if	return
del	import	try
elif	in	while
else	is	with
except	lambda	yield

Python 引号

Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串。

引号的开始与结束必须是相同类型的。

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

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

Python注释

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

实例

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 文件名：test.py

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

Python赋值运算符

以下假设变量a为10，变量b为20：

运算符	描述	实例
=	简单的赋值运算符	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

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

Python成员运算符

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

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

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。

Python运算符优先级

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

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

变量和简单数据类型

变量的命名和使用

变量名只能包含字母、数字和下划线。变量名可以字母或下划线打头，不能以数字打头

变量名不能包含空格，但可使用下划线来分隔其中的单词

不要将Python关键字和函数名用作变量名

字符串

Python 的字符串内建函数

join()函数-分隔符创造新字符串

# join（seq）以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
#对序列进行操作（分别使用' '与':'作为分隔符）

>>> seq1 = ['hello','good','boy','doiido']
>>> print(' '.join(seq1))
hello good boy doiido
>>> print(':'.join(seq1))
hello:good:boy:doiido


#对字符串进行操作

>>> seq2 = "hello good boy doiido"
>>> print(':'.join(seq2))
h:e:l:l:o: :g:o:o:d: :b:o:y: :d:o:i:i:d:o


#对元组进行操作

>>> seq3 = ('hello','good','boy','doiido')
>>> print(':'.join(seq3))
hello:good:boy:doiido


#对字典进行操作

>>> seq4 = {'hello':1,'good':2,'boy':3,'doiido':4}
>>> print(':'.join(seq4))
boy:good:doiido:hello


#合并目录

>>> import os
>>> os.path.join('/hello/','good/boy/','doiido')
'/hello/good/boy/doiido'

split()函数

str.split(str="",num=string.count(str))[n]

str:表示为分隔符。默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等，但是不能为空(’’)。若字符串中没有分隔符，则把整个字符串作为列表的一个元素

num:表示分割次数。默认为 -1, 即分隔所有，如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量

返回值：返回分割后的字符串列表。

#分离字符串
str = "www.csdn.net"
print(str.split('.'))

修改字符串大小写

s = "str test"
print(s.title())
print(s.upper())
print(s.lower())

删除空白

s = '  sdfa  '
// 移除左边空白
s.lstrip()
print(s)
print(s.lstrip())

合并字符串

first_name = 'kun'
last_name = 'kun'
full_name = first_name + " " + last_name	
print(full_name)
print(f'{first_name} {last_name}')

数字

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

• 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。

• 长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L。

• 浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

• 复数(complex numbers) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

类型转换

int(x [,base ])         将x转换为一个整数  
long(x [,base ])        将x转换为一个长整数  
float(x )               将x转换到一个浮点数  
complex(real [,imag ])  创建一个复数  
str(x )                 将对象 x 转换为字符串  
repr(x )                将对象 x 转换为表达式字符串  
eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象  
tuple(s )               将序列 s 转换为一个元组  
list(s )                将序列 s 转换为一个列表  
chr(x )                 将一个整数转换为一个字符  
unichr(x )              将一个整数转换为Unicode字符  
ord(x )                 将一个字符转换为它的整数值  
hex(x )                 将一个整数转换为一个十六进制字符串  
oct(x )                 将一个整数转换为一个八进制字符串  

数据容器分类依据：

是否支持重复元素

是否可修改

是否有序

分为五类：

列表（list）元组(tuple)字符串(str)集合(set)字典(dict)

列表

定义格式：定义，嵌套

#字面量
[元素1, 元素2, 元素3, 元素4, 元素5]

#定义元素
变量名称 = [元素1, 元素2, 元素3, 元素4, ...]

#定义空元素
变量名称 = []
变量名称 = list() # 以圆括号作为空列表

#案列
name_list = ['MXLS, '520', 'SLN']
print(name_list)
print(type(name_list))

#嵌套
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

其中列表内的每一个数据，称之为元素

元素类型不限制

记得逗号+空格

访问对应元素-列表下标（索引）-正反向

#正向
name_list = ['MXLS, '520', 'SLN']
print(name_list[0])    #结果：MXLS
print(name_list[1])    #结果：520
print(name_list[2])    #结果：SLN
print(type(name_list))

#反向
name_list = ['MXLS, '520', 'SLN']
print(name_list[-1])    #结果：SLN
print(name_list[-2])    #结果：520
print(name_list[-3])    #结果：MXLS
print(type(name_list))

#嵌套
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[1][1])    #结果：5

下标越界：list index out of range

列表常见操作

查询下标	my_list.index(元素)	返回list列表的元素下标索引（正向）
插入元素	my_list.insert(下标， 元素) my_list.append(元素) my_list.extend([4, 5, 6])	指定下标位置，插入指定元素 将指定元素，追加到列表的尾部 将其他数据容器取出，依次追加到列表尾部
删除元素	del列表[下标] 列表.pop(下标) 列表.remove(元素)	指定下标位置，删除指定元素 指定下标位置，取出指定元素，可以更改列表，同时赋值给变量 删除某元素在列表中的第一个匹配项（仅删除一次）
清空列表	my_list.clear()	清空列表
修改元素	my_list[2] = 0	指定下标位置，进行赋值，即可以修改元素
统计个数	列表.count(元素) len(列表)	统计某元素在列表内的数量 统计列表的元素个数

修改添加删除列表

# 访问列表元素
l = [1, 2 ,3, 'asdf']
print(l[1])

# 修改列表元素
l[2] = 4
print(l)

# 插入 insert（）
l.insert(0, 9)  # 在列表索引为0的地方插入元素9
# 追加 append（）
l.append(2)     # 末尾追加元素2

# 删除语句
del l[1]  # 删除索引元素
l.pop() # 删除末尾元素
l.remove('asdf')
#统计个数
count = len(my_list)
print(f"列表的元素个数为：{count}")

组织列表-方法调用

# 永久排序
sort()
# 临时排序
sorted()
# 反转列表
reverse()
# 列表长度
len()

操作列表

# 遍历列表
# while
index = 0
while index < len(my_list)： 
    element = my_list[index]
    print(f"列表元素：{element}")
    index += 1
 
 l = [i for i in range(1, 10)]
# for
 for i in l:
    print(i)
  

# 创建数值列表 

# range函数
for i in range(1,5):
    print(i)
numbers = list(range(1, 6))
print(numbers)
print(type(numbers))

# 使用range()函数指定步长
numbers = list(range(1, 30, 2))


# 对数字列表执行简单统计运算
numbers = list(1, 10)
print(min(numbers))
print(max(numbers))
print(sum(numbers))

# 列表解析
l = [i for i in range (1, 11)]

# 切片
l[3:5]
# 用切片复制列表
new_list = old_list[:]

元组

列表和元组的区别

列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。

定义：使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型

# 定义元组字面量
(元素, 元素, 元素, 元素)
# 定义元组变量
变量名称 = (元素, 元素, 元素, 元素)
# 定义空元组
变量名称 = ()
变量名称 = tuple()

#定义一个元组-必须包含逗号
t1 = ('hello',)

修改元组

# 元组不可修改，但是可以重新复赋值
x = (1, 2, 4)
print(x)

old_tuple = (1, 2)
print(old_tuple)

new_tuple = (3, 4)
print(new_tuple)
# 元组中只包含一个元素时，需要在元素后面添加逗号

#嵌套
t1 = ((1, 2, 3), (4, 5, 6))

元组-常用方法

查询下标	my_list.index(元素)	index = t1.index(元素)
下标索引	num = t1[1][1]
统计个数	列表.count(元素) len(列表)	num = t1.count(元素) num = t1.len(t1)

遍历：

# 遍历列表
# while
index = 0
while index < len(t1)： 
    element = t1[index]
    print(f"列表元素：{element}")
    index += 1
 
# for
 for element in t1:
    print(element)
  

注意点：

元组嵌套的内部列表可以被修改

通过下标索引寻找元素，既可以找到可修改的列表

字典

可以通过key寻找到value,如：通过姓名寻找到学生的成绩信息

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key:value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

键值对：key:value

# 定义字典的字面量
{key: value, key: value, ...key: value}
# 定义字典变量
my_dict = {key: value, key: value, ...,key: value}
# 定义空字典
my_dict= {}
my_dict= dict()
# 案列
my_dict1 = {"王力宏": 99,"周杰伦"：88, "林俊杰"：77}
print(f"字典的内容是：{my_dict1}， 类型：{type(my_dict1)}")

注意点：

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住.

即为key不变，但是value的值会被后面value 覆盖

访问字典里的值

即通过key，显示value的值

a_dict = {'name': 'python3', 'age': 15}
print(a_dict['name'])    # 显示python3 
print(a_dict['age'])     # 显示15

修改字典

通过key，修改value的内容

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8 # 更新
tinydict['School'] = "RUNOOB" # 添加
 
 
print ("tinydict['Age']:" , tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])

删除字典-del

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 
del tinydict['Name']  # 删除键是'Name'的条目
tinydict.clear()      # 清空字典所有条目
del tinydict          # 删除字典

遍历字典

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}	
# 遍历字典的键值对
for k, v in tinydict.items():
    print(k, v)

# 遍历字典的键
for k in tinydict.keys():
    print(k)
 
# 遍历字典的值
for v in tinydict.values():
    print(v)

注意点：

字典可以嵌套

集合

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

添加、移除、元素

s = set((1, 2, 3))
print(type(s))
s.add(4)
print(s)
s.remove(1)
print(s)
# 清空集合
s.clear()
print(s)

条件控制语句

Python 条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。

可以通过下图来简单了解条件语句的执行过程:

代码执行过程：

if语句

# 示例
test = True
if test:
    print(1)
else:
    print(0)
    
x = int(input())
if x < 8:
    print("x<5")
elif x > 8:
    print("x>8")
else:
    print("x=8")

以下为if中常用的操作运算符:

操作符	描述
<	小于
<=	小于或等于
>	大于
>=	大于或等于
==	等于，比较两个值是否相等
!=	不等于

循环语句

本章节将为大家介绍 Python 循环语句的使用。

Python 中的循环语句有 for 和 while。

Python 循环语句的控制结构图如下所示：

---

while 循环

Python 中 while 语句的一般形式：

while 判断条件(condition)：
    执行语句(statements)……

执行流程图如下：

n = 100
sum = 0
while sum < n:
    sum += 1
print(sum)

# 无限循环
while True:
    ……

for...else

for item in iterable:
    # 循环主体
else:
    # 循环结束后执行的代码

break continue

n = 5
while n > 0:
    n -= 1
    if n == 2:
        break
    print(n)
print('循环结束。')

pass语句

Python pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句，如下实例

for letter in 'Runoob': 
   if letter == 'o':
      pass
      print ('执行 pass 块')
   print ('当前字母 :', letter)
print ("Good bye!")

函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

---

定义一个函数

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

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。

• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

• 函数内容以冒号 : 起始，并且缩进。

• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

语法

Python 定义函数使用 def 关键字，一般格式如下：

def 函数名（参数列表）:
    函数体

def say_hello():
    print("Hello")

函数调用&&传参

def printme(s):
	print(s)
printme("hello everybody")

return 语句

return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。之前的例子都没有示范如何返回数值，以下实例演示了 return 语句的用法：

def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total
 
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)

面向对象

Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。

如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。

接下来我们先来简单的了解下面向对象的一些基本特征。

---

面向对象技术简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

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

• **类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

• **数据成员：**类变量或者实例变量用于处理类及其实例对象的相关的数据。

• **方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

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

• **实例变量：**在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

• **继承：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

• **实例化：**创建一个类的实例，类的具体对象。

• **对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

类定义

语法格式如下：

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

class MyClass:
    def __init__(self, i):
        self.i = i
    def f(self):
        return 'hello world'
 
# 实例化类
x = MyClass(100)
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()
t.prt()