Python关键词：

• 基础词：is,None,global,not,with,as,or,yield,assert,import,in,
• 流程词：True,False,Try,finally,except,continue,for,if,elif,else,break,raise
• 函数词：def,return,lambda,pass
• 对象词：class

一、变量的好处？

• 1.保存数据后面的代码使用
• 2.代码的结构会更清晰 规格
• 3.修改代码的时候方便 如果多出使用了一个变量 但是这个变量的值一旦改变 那么所用这个变量的代码也都会改变。

例如：

a = 1 # 那么也就是说 a是变量名 1是变量的值 最终我们把 1 赋值给了变量名 a 那么a就等于1

以下是a的运行结果

a = 1
print(a)
1

那么如果a = '1' # 在这里1 加了引号，所以它就不是一个整数了 它变成了一个字符串 如下：

a = '1'
print(a)
1

我们可以使用type（）来查看a是什么类型如下：

type(a)
str # 在这里的str就代表着字符串的意思，如果是数字 那么就是int类型

二、我们要注意变量的命名规则：

• 1.变量名不能使用中文 比如：延凯 = "zhangsan" 这是不行的
• 2.变量名要写有含义的变量名如：name 而不是 mingzi 也不是 名字，或者：My_Name = yanzan
• 3.变量名不能起Python的关键词如：if elif else false true 等等....
• 4.连接符的话我们可以使用_ 如 My_name = yanzan

num = 4 # 首先我们这里num就是number的缩写，那么num = 4 那么也就是4赋值给了变量名num 
print(num) # 所得出来的结果就是Num 是 4
name = 'yanzan' # 在这里我们写了name = 'yanzan' 那么在这里我们加了单引号所以yanzan它是一个字符串
print(name)
'yanzan'

查看name以及num的类型

type(name) # 查看name的类型 就是str 如果是数字就是int 
str
type(num) # int就是整数的意思
int

三、变量整数的运算

例如1：

integer = 3 + 5
print(integer)
8 # 结果就是8

变量与变量赋值

mail = integer + 10
print(mail)
18

例如3：

integer = 10
mail = 5 + (4 - 3) * integer * 2
print(mail)
25

四、数学运算

其实在Python中比如我们要写号码 但是号码太长我们可以这么做

My_Iphone = 152_1000_2727_23232_7673
print(My_Iphone)
15210002727232327673 # 输出结果
type(My_Iphone) # 查看类型
int # 数字

字符串

name = input('name：')
name：MC.Lee
"zhangsan \
lisi \
wangwu \
"
'zhangsan lisi wangwu '

五、列表是什么?

以表格为容器，装载着文字或图表的一种形式，叫列表。

什么意思？

以csdn官网举例子如下：

首页

博客

学院

下载

GitChat

TinyMind

论坛

问答

商城

VIP

活动

招聘

ITeye

那么以上我们就可以称为列表;

2、开始编写Python列表

在Python中的列表其实就是两个中括号括起来如：[] 那么这就是一个列表

当我们查询某个字符串或者数字的类型时使用type能够查看类型，那么我们使用type查看[] 看看是什么类型如下：

type([])
list # 这里的list就是列表的意思

例如1：

my_list = [1, 2, 3, 4, 5,]
print(my_list) # 打印输出my_list变量
[1, 2, 3, 4, 5] # 输出结果

例如2：

Yanzan_list = ["zhangsan", 1, "123", True, False] # 尽量不要用多种类型来定义列表 不建议
print(Yanzan_list)
['zhangsan', 1, '123', True, False] # 输出结果

在上面的列表中我们定义了字符串str 定义了数字 int 同时也定义了True,以及False。 但是在一个列表中定义很多种类型是不建议的！！！ 本章演示除外~~~

3、更新列表对列表进行增删改查

append(附加；贴上；盖章)

使用：

my_list = [1, 2, 3, 4, 5,] # 定义列表my_list
my_list.append("zhangsan") # 在my_list列表中附加上zhangsan字符串
my_list # 输出列表
[1, 2, 3, 4, 5, 'zhangsan'] # 输出结果

insert( 插入；嵌入)

使用：

my_list.insert(3,"lisi") # 在3的位置上添加lisi
my_list # 输出
[1, 2, 3, 'lisi', 4, 5, 'zhangsan']

列表都是从0开始算的如下：

[1, 2, 3, 'lisi', 4, 5, 'zhangsan']------------>0 1 2 3 4 5 6

[ : ] 用法：

目前的my_list内容如下：

[1, 2, 3, 'lisi', 'lisi', 4, 5, 'zhangsan']
my_list[:4] # 取前4个值 ： 在前面
[1, 2, 3, 'lisi'] # 输出结果

no2.

[1, 2, 3, 'lisi', 'lisi', 4, 5, 'zhangsan']
my_list[4:]
['lisi', 4, 5, 'zhangsan'] # 输出结果

count (计算)

[1, 2, 3, 'lisi', 'lisi', 4, 5, 'zhangsan']
my_list.count("zhangsan") # 计算my_list列表中有几个zhangsan

比如我们在my_list列表中创建一个zhangsan字符串 如下

print(my_list)
[1, 2, 3, 'lisi', 'lisi', 4, 5, 'zhangsan']
my_list.insert(8,"zhangsan")
print(my_list)
[1, 2, 3, 'lisi', 'lisi', 4, 5, 'zhangsan', 'zhangsan']

再次使用count在my_list列表中有几个 如下：

my_list.count("zhangsan")
2

index (索引)

其实index用法很简单，一句话其实它就相当于一个导航来告诉我们想要找东西在什么位置如下：

print(my_list)
[1, 2, 3, 4, 'lisi', 5, 'zhangsan', 'zhangsan']
my_list.index("lisi") # 查询my_list列表中的lisi在什么位置
4

pop (删除)

print(my_list) # 输出my_list列表内容
[1, 2, 3, 4, 'lisi', 5, 'zhangsan', 'zhangsan']

删除lisi

my_list.pop(4)
'lisi'
print(my_list)
[1, 2, 3, 4, 5, 'zhangsan', 'zhangsan']

clear (清除)

print(my_list)
[1, 2, 3, 4, 5, 'zhangsan', 'zhangsan']
# 清除列表内容如下：
my_list.clear()
print(my_list)
[] # Null

列表的嵌套

例:

My_list = [1, 2, 3, 4, 5,]
My_Name = ["zhangsan", "lisi", "wangwu", "zhouliu", [My_list], "yanzange"]
print(My_Name)
['zhangsan', 'lisi', 'wangwu', 'zhouliu', [[1, 2, 3, 4, 5]], 'yanzange']

复制

names = ['lmc','wly',['xiaoming','xiaowang'],'tom']
names2 = names.copy()
#copy复制第一层，第二层复制的是列表元素指向的内存地址
#浅copy
#修改copy前外层不会导致copy后数据改变，修改内层会让copy数据一同改变
names[1]='123'
names[2][1]='amy'
print('names:',names)
print('names2:',names2)
names:['lmc','123',['amy','xiaowang'],'tom']
names2:['lmc','wly',['amy','xiaowang'],'tom']

import copy
?
person = ['name',['a',100]]
#三种浅copy的方式
p1=copy.copy(person)
p2=person[:]
p3=list(person)

浅copy的例子

p1=person[:]#基于person的浅copy
p2=person[:]
p1[0]='lmc'
p2[0]='wly'
p2[1][1]=900
print(p1)
print(p2)
['lmc', ['saving', 900]]
['wly', ['saving', 900]]

深copy

import copy
name2 = copy.deepcopy(names)

元组

• 元组不可增删改
• 元组可认为是静态列表

#语法例：
names = ('lmc','wly','tom')
#元组只有两个方法
#index获取下标，count统计个数

• 元组的基本用法和列表一致，但它拥有上述两个特性

什么是字典？

• 字典一种key - value 的数据类型，使用就像我们上学用的字典，通过笔划、字母来查对应页的详细内容。
• 语法:

info = {
 'stu1101': "TengLan Wu",
 'stu1102': "LongZe Luola",
 'stu1103': "XiaoZe Maliya",
}

• 字典的特性：
• dict是无序的，没有下标
• key必须是唯一的,so 天生去重
• 查找

#安全查找的方式
info.get(key)
#有返回key对应的value,无返回None
----------------------------------------------
使用info[key]方式获取数据时，没有这个key会报错
----------------------------------------------
判断是否存在一个key
key in info
返回True存在，False不存在

其他用法

#values
>>> info.values()
dict_values(['LongZe Luola', 'XiaoZe Maliya'])
?
#keys
>>> info.keys()
dict_keys(['stu1102', 'stu1103'])
?
?
#setdefault有对应的key不覆盖，没有则创建
>>> info.setdefault("stu1106","lmc")
'lmc'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'lmc'}
>>> info.setdefault("stu1102","龙泽萝拉")
'LongZe Luola'
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'lmc'}
?
?
#update 有key的更新，没对应的key则创建
>>> info
{'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1106': 'lmc'}
>>> b = {1:2,3:4, "stu1102":"龙泽萝拉"}
>>> info.update(b)
>>> info
{'stu1102': '龙泽萝拉', 1: 2, 3: 4, 'stu1103': 'XiaoZe Maliya', 'stu1106': 'lmc'}
?
#items 字典转列表
info.items()
dict_items([('stu1102', '龙泽萝拉'), (1, 2), (3, 4), ('stu1103', 'XiaoZe Maliya'), ('stu1106', 'lmc')])
?
?
#通过一个列表生成默认dict,有个没办法解释的坑，少用吧这个
#坑：多层字典时，value指向同一个内存地址，类似浅copy
>>> dict.fromkeys([1,2,3],'testd')
{1: 'testd', 2: 'testd', 3: 'testd'}

• 循环dict

#方法1
for key in info:
 print(key,info[key])
?
#方法2
for k,v in info.items(): #会先把dict转成list,数据里大时莫用
 print(k,v)

集合

集合是一个无序的，不重复的数据组合，它的主要作用如下：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

s = set([3,5,9,10]) #创建一个数值集合 
 
t = set("Hello") #创建一个唯一字符的集合 
?
?
a = t | s # t 和 s的并集 
 
b = t & s # t 和 s的交集 
 
c = t – s # 求差集（项在t中，但不在s中） 
 
d = t ^ s # 对称差集（项在t或s中，但不会同时出现在二者中） 
 
 
 
基本操作： 
 
t.add('x') # 添加一项 
 
s.update([10,37,42]) # 在s中添加多项 
 
 
 
使用remove()可以删除一项： 
 
t.remove('H') 
 
 
len(s) 
set 的长度 
 
x in s 
#测试 x 是否是 s 的成员 
 
x not in s 
#测试 x 是否不是 s 的成员 
 
s.issubset(t) 
s <= t 
#测试是否 s 中的每一个元素都在 t 中 
 
s.issuperset(t) 
s >= t 
#测试是否 t 中的每一个元素都在 s 中 
 
s.union(t) 
s | t 
#返回一个新的 set 包含 s 和 t 中的每一个元素 
 
s.intersection(t) 
s & t 
#返回一个新的 set 包含 s 和 t 中的公共元素 
 
s.difference(t) 
s - t 
#返回一个新的 set 包含 s 中有但是 t 中没有的元素 
 
s.symmetric_difference(t) 
s ^ t 
#返回一个新的 set 包含 s 和 t 中不重复的元素 
 
s.copy() 
#返回 set “s”的一个浅复制