.1# 数的定义：
#
格式化：
format ---字符串拼接
%d,%f,%s 格式化输出
str()、int()、float()强转类型函数
#age=int(input('请输入您的年龄：'))
#print ( age-1)
#强转化的函数例子
#age=int(input('请输入您的年龄：'))
#print ( '你的周岁是：'+str(age-1))
#age=input('请输入你的年龄：')
#print('你的周岁是：'+str(int(age)-1))
强转类型的函数总结（int、float、str）
1.如果想要将一个整数和浮点与一个字符串连接，str()函数比较方便
2.如果有一个些字符串，希望将他们用于数值运算，int()函数比较方便
3.如果将一个不能求值为整数的值传递给int(),python报错valueErro.
4.如果需要对浮点数进行取整运算，也可以int（）函数。
#编写一个程序（可以询问姓名和年龄，并且告知姓名的字符个数和你明年的年龄）
#综合数据类型-list
列表 list 是处理一组有序项目的数据结构，即你可以在一个列表中存储一个序列的项目。
常规操作： 访问列表中的值 、更新列表、删除列表元素、列表函数&方法。
使用方括号定义列表。 type() 查看类型
str(11)
'11'
float(11)
11.0
定义列表：
list1=[1,1,2,3,]
list1
[1, 1, 2, 3]
查看类型：
type(list1)
<class 'list'>
访问列表：
len(list1)
4
print(list1[2])
2
print(list1[1])
1
print(list1[0])
1
双重列表：
list2=[1.,2.,3.,4.]
list3=[list1,list2]
print(list1)
[1, 1, 2, 3]
print(list2)
[1.0, 2.0, 3.0, 4.0]
print(list3[0])
[1, 1, 2, 3]
print(list3[0] [2])
2
print(list3[1] [2])
3.0
print(list3[1] [2])
3.0
print(list3[1] [3])
4.0
print(list3)
[[1, 1, 2, 3], [1.0, 2.0, 3.0, 4.0]]
list3
[[1, 1, 2, 3], [1.0, 2.0, 3.0, 4.0]]
更新列表：
list3[0]=[1,2,3,4,5,6,7,8,]
list3
[[1, 2, 3, 4, 5, 6, 7, 8], [1.0, 2.0, 3.0, 4.0]]
del list3[0]
删除列表
list3
[[1.0, 2.0, 3.0, 4.0]]
插入数据列表：
list1=[1,2,3,4]
list1.append('11')
list1
[1, 2, 3, 4, '11']
统计元素出现的次数
print(list1.count(2))
1
追加列表
list1.extend[1,2,3]
list1
[1,2,3,4,11,1,2,3]
在定制的索引位置添加元素
list1.insert(4,'22')
list1
[1,2,3,4,'22',11,1,2,3]
删除指定坐标的元素
list1.pop(2)
3
list1
[1, 2, 4, '22', 11, 1, 2, 3]
remove移除列表某个值第一次匹配的项
list1.remove(1)
list1
[2, 4, '22', 11, 1, 2, 3]
方向列表
list1.reverse()
list1
[3, 2, 1, 11, '22', 4, 2]
排序列表 sort
list1.sort()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unorderable types: str() < int()
报错，因为列表有字符串，先删掉字符在排序而python2不会报错这样错的。
list1
[1, 2, 3, 11, '22', 4, 2]
指定删除某个元素
list1.pop(4)
'22'
list1
[1, 2, 3, 11, 4, 2]
list1.sort()
list1
[1, 2, 2, 3, 4, 11]
切片：
list1=[1,2,2,3,4]
print(list1[2:4])
[2, 3]
print(list1[1:4])
[2, 2, 3]
print(list1[-2:-4])
[]
print(list1[-4:-2])
[2, 2]
元祖 tuple
python的元组合列表类似，不同之处在于元组的元素不能修改。
常规操作：
访问元组、修改元组、删除元组 、无关闭分隔符、内置函数
2.定义一个值得元祖
t2=(9)
t2
9
type(t2)
<class 'int'>
定义元祖
t3=()
type(t3)
<class 'tuple'>
t1=(1,2,3,4,4)
type(t3)
<class 'tuple'>
t3
()
t1
(1, 2, 3, 4, 4)
访问元组
t1
(1, 2, 3, 4, 4)
print (t1[1])
修改元组元素 不能修改（保证数据安全），可以先转化为列表 在修改后在转元组。
egg=('hello',2,3,4,5)
egg[1]=99
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
删除元组
del t1
t1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 't1' is not defined
无关闭分隔符。
type(('hello'))
<class 'str'>
type(('hello',))
<class 'tuple'>
多元素赋值
x,y,z=(1,2,3)
print(x，x,y)
1,2,3
例题：
x=2,y=3 进行互换：
1.使用变量，进行赋值
x=2
y=3
z=x
x
2
z
2
x=y
x
3
y=z
y
2
B.使用
x=2
y=3
x,y=(y,x)
print(x,y)
3 2
元组的优势
1.可以用元组告诉所有读代码的人，你不打算改变这个序列的值
如果需要一个永远不改变的值的序列，就使用的元组
2.因为元组的不可变性，内容不会变化的，python可以实现一些优化，让使用元组的代码闭
使用列表代码更快。
综合数据类型-dict
字典-dict
字典是另一种可变容器模型，且可存储任意类型对象。
常规操作。
访问字典里的值
修改字典
删除字典元素
字典键的特性
字典内置函数&方法
-花括号定义 键值对形式存在
dict={'a':1,b:2}
type(dict)
<class 'dict'>
在字典中，键是唯一的，如果存在两个一样的键，后者会替代前者
#键不可变得，可以使用数字，字符串，元组，但是列表不行
访问字典
print(dict2['a'])
4
如果访问不存在的键，会报错keyerro.
dict1['c']+dict1['a']+dict1['b']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'a'
--->>在列表中不存在的下标不能进行元素的修改。
----》》在字典中可以直接设置一个不存在的键，并且给他一个值
list1[6]=10
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list assignment index out of rangedict1
{'c': 1, 'b': 2}
dict1['a']=dict1['c']+dict['b']
dict1
{'c': 1, 'a': 21, 'b': 2}
删除字典中的元素
del dict2['c']
dict2
{'a': 4, 'b': 2}
清空：dict2.clear()
dict2.clear()
dict2
{}
字典函数：
创建一个字典，以序列中的元素作为新字典的键，val作为字典的使用键的初始值。
dict.fromkeys(seq,val)
如：
dict3={}
dict4=dict3.fromkeys([1,2,3,4],0)
dict4
{1: 0, 2: 0, 3: 0, 4: 0}
dict3
{}
当访问一个不存在键会报错，
为了避免返回错误，影响程序正常的运行
dict.get(key,default=value)
返回指定键的值，如果键不存在，返回default默认值value
dict5={'a':1,'b':2}
print(dict5.get('b','没有这个值'))
2
print(dict5.get('c','没有这个值'))
没有这个值
ID 名字 年龄
1 后裔 24
2 嫦娥 30
3 露露
dict1={1:{'ID':'001','名字':'后裔','年龄':24},2:{'ID':'002','名字':'嫦娥','
年龄':30},3:{'ID':'003','名字':'露露'}}
print(dict1[3].get('年龄',25))
25
9.与get类似，区别键不存在，增加键，并赋值。
dict.setdefault(key,value)
print(dict1.setdefault('年龄',18)) *与dict1 元素并列了*** .
18
dict1
{1: {'名字': '后裔', '年龄': 24, 'ID': '001'}, 2: {'名字': '嫦娥', '年龄': 30, '
ID': '002'}, 3: {'名字': '露露', 'ID': '003'}, '年龄': 18}
del dict1['年龄']
print(dict1[3].setdefault('年龄',18))
18
dict1
{1: {'名字': '后裔', '年龄': 24, 'ID': '001'}, 2: {'名字': '嫦娥', '年龄': 30, '
ID': '002'}, 3: {'名字': '露露', '年龄': 18, 'ID': '003'}}
判断字典中是否存在某个键
dict1
{'a': 0, 'b': 'meiyou'}
print('a' in dict1)
True
返回字典中所有的键、所有的值。
dict.keys()/dict.values()
dict7={0:[1,2,3],1:[2,3,4],2:[4,5,6]}
print(dict7.keys())
dict_keys([0, 1, 2])
print(dict7.values())
dict_values([[1, 2, 3], [2, 3, 4], [4, 5, 6]])
把字典中键/值更新到另一个字典中。
dict.update()
dict1_1={'a':1,'b':2}
dict1_2={'c':3,'d':4}
dict1_1.update(dict1_2)
dict1_1
{'a': 1, 'b': 2, 'd': 4, 'c': 3}
数据综合类型-set&序列、切片
A.序列和分片
str1='my name is leon'
#1.取得name子串
str1='my name is leon'
print(str1[3:7])
nameprint(str1[-12:-8])
name
#2.取得leon子串
print(str1[11:])
leon
print(str1[-4:])
leon
F.集合 set
集合（set）和字典（dict）类似，它是一组key的集合，但不存储value.
集合的特性就是：key不能重复，唯一。
常用操作：
创建集合
遍历集合
添加元素
交集、并集、差集
-花括号定义-
s1={'a','b','c'}
type(s1)
<class 'set'>s2=set('abc')
s2
{'a', 'b', 'c'}
type(s2)
<class 'set'>
访问 通过循环结构
for e in s2 :print(e)
...
a
b
c
转化列表在访问
list1=list(s2)
print(list1[0])
a
增加元素
s3=set('abcder')
s3.add('g')
s3
{'d', 'r', 'g', 'e', 'b', 'c', 'a'}删除元素
s3.remove('a')
s3
{'d', 'r', 'g', 'e', 'b', 'c'}
交集、并集，差集
交集
set4_1=set('acvsdf')
set4_2=set('aacvskk')
print(set4_1&set4_2)
{'a', 'v', 's', 'c'}并集：
print(set4_1|set4_2)
{'d', 'k', 'v', 'c', 'f', 'a', 's'}
差集
print(set4_1-set4_2)
{'d', 'f'}print(set4_2-set4_1)
{'k'}
