python day1
本节内容
数据类型与变量
运算符
数值
字符串与编码
list与tuple
条件判断
循环
dict与set
一、数据类型与变量
计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型
Python3 中有六个标准的数据类型：
- Number（数字）：int、float、bool、complex（复数）
- String（字符串）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
Python3 的六个标准数据类型中：
- 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
- 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
变量：
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
等号（=）用来给变量赋值。
等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值
# 变量 name='Drango War' #字符串变量 price=12.5 #浮点型变量 id=100 #整数型变量 # 输出 print(name) print(price) print(id)
运行结果：
Drango War
12.5
100
Python允许你同时为多个变量赋值
a=b=c=5 print(a) print(b) print(c) 5 5 5
创建一个整型对象，值为 5，从后向前赋值，三个变量都指向同一个内存地址
name,price,id="Drango War",12.5,100 字符串对象 name赋值 Drango War 浮点型 price 赋值 12.5 整数型 id 赋值 100
python中有一个函数type(),可以获取变量的数据类型：
a,b,c,d=10,12.6,True,"Drango War" print(type(a),type(b),type(c),type(d)) <class 'int'> <class 'float'> <class 'bool'> <class 'str'>
python中的变量可以删除： 使用 del
a,b,c,d=10,12.6,True,"Drango War" print(type(a),type(b),type(c),type(d)) ## 删除变量 del a print(a) <class 'int'> <class 'float'> <class 'bool'> <class 'str'> Traceback (most recent call last): File "F:/pythonDemo/day1/demo1.py", line 36, in <module> print(a) NameError: name 'a' is not defined
注意：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加
Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型：
a=10+5j print(type(a)) b=complex(5,10j); print(type(b)) <class 'complex'> <class 'complex'>
二、运算符：
python中的运算符：
算术运算符
比较运算符
赋值运算符
逻辑运算符
位运算符
成员运算符
身份运算符
运算符优先级
1.算术运算符
数值型：数值运算
a,b=10,20 print(a+b)# 加法 print(a-b)# 减法 print(a*b)# 乘法 print(a/b);# 除法，得到一个浮点数 print(a//b)# 除法，得到一个整数 print(a%b)# 取余 print(a**b)# 乘方 30 -10 200 0.5 0 10 100000000000000000000
注意：
- 1、Python可以同时为多个变量赋值，如a, b = 1, 2。
- 2、一个变量可以通过赋值指向不同类型的对象。
- 3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
- 4、在混合计算时，Python会把整型转换成为浮点数
2.比较运算符
赋值运算符
a = 21 b = 10 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)
1 - c 的值为： 31 2 - c 的值为： 52 3 - c 的值为： 1092 4 - c 的值为： 52.0 5 - c 的值为： 2 6 - c 的值为： 2097152 7 - c 的值为： 99864
位运算符（了解）
#!/usr/bin/python3 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
逻辑运算符：
flag=True flags = False print(flag and flags) print(flag or flags) print(not flag) False True False
成员运算符
这个在我们学习列表时来学习。
身份运算符：
身份运算符用于比较两个对象的存储单元
使用函数 id(）可以获取对象的内存地址
a=200 b=200 print(a is b) b=30 print(a is b) print(a is not b)
print(id(a) is id(b))
True
False
True
False
注意：is判断的是两个变量引用对象是否为同一个，==号判断的引用变量的值是否相等
运算符优先级
三、数值型
Python 数字数据类型用于存储数值。
数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。
Python 支持三种不同的数值类型：
- 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
- 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
- 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
数值型的转换：
-
int(x) 将x转换为一个整数。
-
float(x) 将x转换到一个浮点数。
-
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
-
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
a=12.9 print(int(a)) b=12 print(float(b)) print(complex(b))
12
12.0
(12+0j)
String （字符串）
python中的字符串使用 单引号''或者双引号""括起来。
字符串有下标：从0开始
如果从末尾开始下标是从-1开始
截取字符串：
变量[开始的下标:结束的下标]
name="Drango War" # 截取:包含开始下标，不包含结束的下标 print(name[1:5]) #从1开始截取到下标到5 print(name[1:]) #从1开始截取到最末尾 print(name[3]) #取出下标是3的字符 print(name*3) #字符串输出3边 print(name+"python") #name拼接上python 字符串连接 rang rango War n Drango WarDrango WarDrango War Drango Warpython
加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，紧跟的数字为复制的次数
Python 使用反斜杠(\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串
print('Ru\noob')#转义符会转义 print(r'Ru\noob')#原样输出
python中的多行字符串：使用"""......"""或者'''.....''''来显示
注意：python中没有字符型，一个字符就是一个长度位1的字符串。
注意：
- 1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
- 2、字符串可以用+运算符连接在一起，用*运算符重复。
- 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
- 4、Python中的字符串不能改变。
字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
name="Drango War" print("我的名字是%s,我是程序员"%name) a=20 print("%d"%a) b=12.907 print("%2.2f"%b) 我的名字是Drango War,我是程序员 20 12.91
编码：
编码类型：
1、ascci码
ascci码由美国人发明，用1个字节（byte）存储英文和字符，前期用了128个，后来新加了其他欧洲国家的符号，128~255这一段。
256个字符，基本上就是键盘上的所有字符。
2、unicode
2个byte，65535。因为后来发现还有其他国家的语言，而256个字符太少。
3、utf-8
UTF-8是Unicode的实现方式之一。
UTF-8最大的一个特点，就是它是一种变长的编码方式。它可以使用1~4个字节表示一个符号，根据不同的符号而变化字节长度。
GBK
GBK全称《汉字内码扩展规范》（GBK即“国标）就是国家制定的标准。
其实GBK在就是将每个汉字对应一个数字编码
在程序运行过程中如果遇到编码不一致（就好像中国人和美国人在一起，如果语言不通的话，就无法沟通。），就需要进行转码。相当于需要有一个翻译
转码：
unicode为桥梁，utf-8和gbk互转需要经过unicode这个翻译，不然他们二者是无法直接沟通。
decode将别的字符编码转换位unicode编码
encode将unicode编码转换为其他的编码
五、list与tuple
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推：
列表 list与元组 tuple就是常见的序列。
创建列表：
#创建一个空的列表 lists=[] #创建一个列表：列表可以存储不同类型的数据 a=['Drango War',20,'男'] print(lists) print(a)
访问列表中的值：
#访问列表中的值 #根据下标来访问 print(a[0]) #访问列表中从0下标开始 共2个值 print(a[0:2])
更新列表
a=['Drango W # 修改元素 print(a[1]) a[1]=50 print(a[1]) # 添加元素：添加到末尾 a.append("中国 print(a) # 向指定下标添加元素 a.insert(1," b=['悟空',500, # 在列表末尾一次性追加 a.extend(b) print(a) 20 50 ['Drango War', 50, '男', '中国'] ['Drango War', 'IT', 50, '男', '中国', '悟空', 500, '花果山']
删除列表元素：
# 列表截取 # 从下标开始截取，截取多 print(a[0:3]) # 从下标开始截取,一直截 print(a[1:])
列表拼接:使用 +号拼接
# 列表拼接 a=['Drango War b=['悟空',500,'花 print(a+b) ['Drango War', 20, '男', '悟空', 500, '花果山']
列表嵌套：
# 列表嵌套 a=['Drango War', b=['悟空',500,'花果山 c=[a,b] print(c) # 取出嵌套的第一个列表中的下标 print(c[0][1])
列表的一些函数的使用：
d=[1,2,4,21,3,5,2] print(len(d))#列表的长度 print(max(d))#返回列表元素最大 print(min(d)) #返回列表 print(d.count(2))#统计某个 print(d.index(4)) #从列 d.reverse() #反向列表中元素 print(d) d.sort() #对原列表进行排序 print(d) f=d.copy() #复制列表 print(f) d.clear() #清空列表 print(d)
7
21
1
2
2
[2, 5, 3, 21, 4, 2, 1]
[1, 2, 2, 3, 4, 5, 21]
[1, 2, 2, 3, 4, 5, 21]
[]
tuple：元组
元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
t=() print(type(t))
f=('Drango War',20,'男')
print(type(f))
<class 'tuple'>
<class 'tuple'>
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：
访问元组
f=('Drango War',20,'男') print(f[1]) print(f[1:3])
元组中的元素不能修改
删除元组
#删除元组 del f print(f) Traceback (most recent call last): File "F:/pythonDemo/day1/demo1.py", line 245, in <module> print(f) NameError: name 'f' is not defined
元组也可以进行拼接与截取
元组函数
f=('Drango War',20,'男') print(len(f)) #元组的长度 print(max(f)) #元组存储的数据类型相同时可以得到最大值与最小值 print(min(f))
元组可以转换列表，列表也可以转换为元组
f=['Drango War',20,'男'] # 列表转元组 print(tuple(f)) h=('Drango War',20,'男') # 元组转列表 print(list(h)) ('Drango War', 20, '男') ['Drango War', 20, '男']
六、条件判断
if语句：
#简单if if 10>9: print("10大于9") else: print("10不大于9") #多重if if 10>9: print("10大于9") elif 20>10: print("20大于10") else: print("10不大于9")
注意：
- 1、每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
- 2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
- 3、在Python中没有switch – case语句
age = int(input("请输入你家狗狗的年龄: ")) print("") if age < 0: print("你是在逗我吧!") elif age == 1: print("相当于 14 岁的人。") elif age == 2: print("相当于 22 岁的人。") elif age > 2: human = 22 + (age -2)*5 print("对应人类年龄: ", human) ### 退出提示 input("点击 enter 键退出")
if 嵌套
在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。
if 表达式1: 语句 if 表达式2: 语句 elif 表达式3: 语句 else: 语句 elif 表达式4: 语句 else: 语句
num=int(input("输入一个数字：")) if num%2==0: if num%3==0: print ("你输入的数字可以整除 2 和 3") else: print ("你输入的数字可以整除 2，但不能整除 3") else: if num%3==0: print ("你输入的数字可以整除 3，但不能整除 2") else: print ("你输入的数字不能整除 2 和 3")
七、循环
python中的循环有for循环以及while循环：循环一定要有退出条件，否则就会成为死循环。
while 循环
while 判断条件： 语句
n = 100 sum = 0 counter = 1 while counter <= n: sum = sum + counter counter += 1 print("1 到 %d 之和为: %d" % (n,sum))
n = 100 sum = 0 counter = 1 while counter <= n: sum = sum + counter counter += 1 print("1 到 %d 之和为: %d" % (n,sum))
for循环
for循环可以遍历任何序列的项目:
for <variable> in <sequence>: <statements> else: <statements>
a=['Drango War',20,'男'] for n in a: print(n)
break 语句，break 语句用于跳出当前循环体
sites = ["Baidu", "Google","Runoob","Taobao"] for site in sites: if site == "Runoob": print("菜鸟教程!") break print("循环数据 " + site) else: print("没有循环数据!") print("完成循环!")
continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
for letter in 'Runoob': # 第一个实例 if letter == 'o': # 字母为 o 时跳过输出 continue print ('当前字母 :', letter) var = 10 # 第二个实例 while var > 0: var = var -1 if var == 5: # 变量为 5 时跳过输出 continue print ('当前变量值 :', var) print ("Good bye!")
八、dict与set
dict ：
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
d = {key1 : value1, key2 : value2 }
dict={} dict1={'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'} print(type(dict)) print(type(dict1)) <class 'dict'> <class 'dict'>
访问字典
print(dict1['Alice']) #根据键访问值
修改字典：
# 修改：根据键修改 dict1['Alice'] =1314 print(dict1)
{'Alice': 1314, 'Beth': '9102', 'Cecil': '3258'}
删除字典元素
#删除字典元素 del dict1['Alice'] print(dict1) {'Beth': '9102', 'Cecil': '3258'}
删除字典：
del dict1
字典：不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
字典的函数
dict1={'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
print(len(dict1))#字典长度
print(str(dict1)) #输出字典，以可打印的字符串表示。
# print(dict1.clear())#删除字典内所有元素
seq = ('name', 'age', 'sex')
dict2=dict1.fromkeys(seq) #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
print(dict2)
print(dict1.get('Alice')) #返回指定键的值，如果值不在字典中返回default值
print('Alice' in dict1) #如果键在字典dict里返回true，否则返回false
print(dict1.items())
# 遍历这个元组
for i,j in dict1.items():
print('key',i,'value',j)
pass
print(dict1.keys()) #和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
print(list(dict1.keys()))
dict1.setdefault("names","Drango War") #和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
print(dict1)
dict1.update(dict2) #把字典dict2的键/值对更新到dict1里
print(dict1)
print(dict1.values()) #返回一个迭代器，可以使用 list() 来转换为列表
print(list(dict1.values()))
print(dict1.pop("names")) #删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
print(dict1.popitem()) #随机返回并删除字典中的一对键和值(一般删除末尾对)。
集合：
集合（set）是一个无序不重复元素的序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
a=set('1234') sets={1,2,3,4} print(type(a)) print(type(sets)) <class 'set'> <class 'set'>：
集合操作
添加：
sets.add(5)
print(sets)
{1, 2, 3, 4, 5}
还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
sets.update([6,7,8])
移除元素
stes.remove(5)
此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误
sets.discard(4)
可以设置随机删除集合中的一个元素
sets.pop()
集合的长度：
len(sets)
清空集合
sets.clear()
判断元素是否在集合中存在
4 in sets
