一、数据类型
计算机里所有的数据都可以看作对象，变量在程序中起到指向数据对象的作用。
python常用的数据类型分为基础数据类型（number，str），复合数据类型（list，tuple，dict，set）
python万物皆对象，即面向对象，任何事物都可以用对象描述。以int为例，既然int是类，则具有属性和方法
基础数据类型
1.number（数值型）
int
float （没有double）
complex
bool
注意：
1)bool类型只有True，False两个取值（首字母大写），因为bool继承了int类型，所以True等价于1，False等价于0。bool类型变量可以参与数学运算
2)非0数值型变量，非空字符串为真，用bool()进行数据类型转换可以得到True
3)float的精度问题
利用decimal包里的Decimal类和getcontext（）函数
2.str（字符串）
存放着Unicode字符序列，用引号将任意字符括起来，可以是单引号，也可以是双引号，三引号（不常用）
注意：
1.在用单引号括起的字符串中若有撇号，则会出错，python会将第一个单引号和撇号之间的内容视为一个字符串。
2.字符串支持索引，索引方式和列表一样，参考后面的列表，也支持切片，见下文。
3.python没有单独的字符类型，C中的char类型
#就近匹配
"'...'" # √
'"..."' # √
""..."" #×
''...'' #×
操作：
s1+s2 #使用+来拼接字符串
'''
修改字符串大小写，注意字符串为不可变类型，只是返回大小写改变的字符串
'''
s.title() #以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。
s.upper() #返回纯大写的字符串
s.lower() #返回纯小写的字符串
s.swapcase() #返回大小写翻转的字符串
s.capitalize() #将字符串的第一个字符大写（如果第一个字符是字母的话）
'''
删除空白，注意并不是永久删除，需要将结果存储到变量
空白：泛指任何非打印字符，eg空格、制表符\t、换行符\n
'''
s.rstrip() #删除末尾的空白
s.lstrip() #删除开头的空白
s.strip() #同时删除开头和末尾的空白
s.find(subs) #查找指定的内容subs在字符串s中是否存在，如果存在就返回内容第一次出现在字符串中的索引值,否则返回-1
s.rfind(subs) #和find类型，不过是从末尾开始检索
s.count(subs) #返回subs出现的次数
s.replace(旧的字符串，新的字符串) #用新的字符串替代旧的字符串，如果指定了次数，则替换个数不会超过指定的数
"""
其他方法
"""
len(s) #获取长度
s.split(参数) #通过参数内容切割字符串，返回列表
s.splitlines() #按行分隔，返回列表，列表的一个元素为一行的字符串内容
s.encode(参数) #以指定编码格式编码
s.decode(参数) #以指定编码格式解码
s.join(list) #list的每个元素为字符串，返回以s为连接符连接列表元素后的字符串
s.isnumeric() #如果字符串只包含数字字符，则返回True，否则返回False
复合数据类型
可以存放多种类型元素的容器称为复合数据类型。python的容器包含序列，映射，集合。
序列包括：str，list，tuple，buffer对象等
唯一的映射类型：dict
集合：set（可变的集合），frozenset（不可变集合）
1.list（列表）
用[ ]表示列表,列表是是包含若干对象引用的有序序列，list的所有数据元素都是对象引用，因此可以存放任何数据类型的变量。
list有索引——列表名称[索引]。索引从0开始，为方便，Python提供了一种特殊语法，通过让索引指定为-1，可让Python返回列表最后一个元素，-2返回倒数第二个元素…
注意： 使用列表索引不要越界，当列表为空时list[-1]会出现错误
操作：
list————创建，增删改查，其他
创建：
'''
1.可以直接通过[]创建，空[]表示空列表，多个数据元素之间用逗号隔开
2.list()函数创建，函数参数最多为一个，当不给参数时，返回一个空列表，要求参数iterable
'''
list=[]
增：
list.append(v) #在列表末尾添加元素v
insert(i,v) #在索引为i的元素前插入v，即v变成索引为i的元素
list1.extend(list2) #将list2的元素逐一添加到list1中
改：
list[i]=v #将索引为i的值修改为v
查:
list[i] #索引
list.index(v) #返回v第一次出现的位置索引，不存在会报错
list.count(v) #统计v在列表中出现的次数
#in,not in
if v in list: #存在返回True，否则返回false
print("存在")
if v not in list: #不存在返回True，否则返回false
print("不存在")
删：
del list[i] #删除索引为i的元素
del a #销毁列表，a不存在
list.pop() #删除最后一个元素,并返回元素的值
list.pop(i) #-删除指定索引位置的元素
list.remove(v) #删除值为v的元素，多个的话删除第一个
len(list) #获悉列表的长度
'''
组织列表
'''
list.sort() #对列表进行从小到大的排序，
list.sort(reverse=True) #从大到小的顺序排列
sorted(list) #对列表进行临时排序，即列表顺序实际不变，只返回排序后列表
#要反序可以给sorted()传递参数reverse=True
list.reverse() #将列表反过来
list[::-1] #返回反向的列表
2.tuple（元组）
列表非常适合用于存储运行期间可能变化的数据集，列表是可以修改的。但我们有时需要创建一系列不可修改的元素，元组可以满足这种需求。
元组是用圆括号()定义的，可以用索引访问元素，可遍历，不可以修改元素。只能修改元组变量的指向。
#元组若元素只有一个的话，需要在元素后面加一个逗号
print(type((1))) #type(数据)返回数据的类型
print(type((1,)))
#输出：
<class 'int'>
<class 'tuple'>
!!!序列seq
list，tuple，str，range
1）切片
————对操作的对象截取其中一部分的操作。
字符串，列表，元组都可以进行切片操作
#以list为例
#创建切片
list[m:n:r] #返回列表从索引m到索引n（不包含），以r为步长截取的列表，省略r则为1
[m:] #返回包含从索引m到末尾的内容
[:n] #返回包含从索引0到n（不包含）的内容
#遍历切片——和遍历列表一样
#复制列表——创建一个包含整个列表的切片，深复制
list_new=list[:]
list_new=list #无效，list_new和new是指向同一个列表，浅复制
2）操作符
3）方法
str(seq)，list(seq)，tuple(seq) #类型转换
len(seq) #返回对象的元素个数
max(seq)
min(seq)
sum(seq[,other]) #返回对象元素与可选参数other的总和
sorted(iterable,key=None,reverse=False) #排序
#iterable可迭代对象，sub都可迭代
#key 用于排序的主关键字
# reverse排序规则，False升序（默认），True降序
reversed(seq) #返回一个反转的序列
enumerate(seq[,start=0]) #用于将一个可遍历对象组合成一个索引序列，同时列出数据和数据下标，start为数据下标的指定起始值，默认为0
zip(iterable1[,iterable2,...]) #用于将可迭代对象作为参数，将对象中对应的元素打包成一个个元素，节约内存，可以用list()转换输出列表，如果各个迭代器元素个数不一样，则返回的列表长度与最短的对象一致，利用*操作符可以将元组解压为列表。
3.dict（字典）
字典是一系列键值对，用{ }括起来，其中每个键都与一个值相关联，
键与值之间用冒号分隔，而键值对之间用逗号分隔。
注意：
1.键不允许相同，值可以相同
2.同一个键的值被修改多次，以最后一次为准，即覆盖处理
3.键是不可变对象（如number，str，tuple）的对象引用，值是指向任意类型对象的对象引用
有关不可变对象的解释：
不可变对象指对象创建了之后不能改变对象的状态
#以str为例，number类似，tuple本身不可修改
s1='fksla'
s2=s1
print(s2 is s1) #此时s1，s2对象引用指向的是同一个对象，同一片内存空间
print(id(s1),id(s2)) #id()返回指向的对象的地址
s1=s1+'s' #这个s1已经不再是之前的s1，并不是指它原来指向的对象的值改变了，而是内存中开辟了一个新的内存存放新的值，而s1是这个新的对象的对象引用，这个和java里的字符串一样
print(s2 is s1)
print(id(s1),id(s2))
#output
# True
# 2623639886384 2623639886384
# False
# 2623639834736 2623639886384
#而像list，dict是可变对象，以list为例
l1=[1,2,'ds']
l2=l1
print(l1 is l2)
print(id(l1),id(l2))
l1.append(2)
print(l1 is l2)
print(id(l1),id(l2))
#output
#
# True
# 2926545055104 2926545055104
# True
# 2926545055104 2926545055104
判断方法
操作
dict————创建，增删改查
创建：
dict={} #创建一个空的字典
dict=dict() #创建一个空的字典
dict=dict([(key,value),(...),(...),...])
dict=dict(key=value) #这种情况下，键只能为字符串类型，并且创建的时候字符串不能加引号，加上就会直接报语法错误
dict=dict.fromkeys(seq[,value]) #以序列seq中的元素做字典的键，value为字典值的初始值） #dict.fromkeys为内置方法
eg:
dict = dict([('apple', 1), ('peach', 2), ('cherry',3)])
# {'apple': 1, 'pench': 2, 'cherry': 3}
dict(apple=1,pench=2,cherry=3)
#{'apple': 1, 'pench': 2, 'cherry': 3}
dict.fromkeys((1,2,3),10)
#{1: 10, 2: 10, 3: 10}
查：
dict[key] #返回value 若不存在则发生异常
dict.get(key) #返回value，若不存在不会出现异常，返回None
if k in dict: #如果k存在就返回v
print(dict[k])
if k not in dict: #如果不存在，就添加一个
dict[k]=v
#修改不成就添加
改：
dict[k]=v
增：
dict[k]=v #不存在的k
删：
del dict[k]
del dict #销毁字典，字典对象不存在
dict.pop(k) #删除指定键值对
dict.clear() #清空字典，变成空字典{}
dict.popitem() #随机删除字典中的一个键值对，前提是字典不为空，否则会报错
其他
dict.copy() #返回一个深复制
dict.update(dict2) #把dict2的键值对更新到dict中，没有的添加进去，有的更新value
dict.keys() #返回一个可迭代对象，可以用list（）来转换为列表，列表为字典中的所有键
dict.values() #返回一个可迭代对象，可以用list（）来转换为列表，列表为字典中的所有值
dict.items() #返回可遍历的（键，值）元组数组
eg
di={1: 10, 2: 10, 3: 10}
di.items()
#dict_items([(1, 10), (2, 10), (3, 10)])
d1={1:1,2:2,3:3}
d2={1:8,9:1,2:1}
d1.update(d2)
d1 #{1: 8, 2: 1, 3: 3, 9: 1}
嵌套
#字典列表，列表的每一个元素都为字典
[{},{},{},....]
#在字典中存储列表，一个键有多个值时，可以用列表存储，对于值需要遍历得到
{key:[],....}
#在字典中存储字典
{key:{},....}
4.set（可变集合）
\quad
python中的set与dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以在set中没有重复元素。
注意： key只能是不可变类型，即可哈希的值，所以集合的元素类型只能是不可变类型。
创建：
set() #创建空的集合或{元素1，元素2,...}直接将一对元素用花括号括起来，但是{}表示空字典而不是集合
set(iterbale) #类型转换，将可迭代的数据eg list,range(),str,tuple
#重复元素在set中会被自动过滤,集合的特点：唯一，无序
添加：
set.add()
set.update(set2) #将set2中的不重复的元素添加到set中
删：
set.remove(value) #删除指定元素，如果元素不存在会出现错误
set.discard(value) #删除指定元素，如果元素不存在不会出现错误
set.pop() #随机删除一个元素
"""
由于set是无序和无重复元素的集合，所以两个或多个set可以做数学意义上的集合操作：交，并，差，判断是否包含，包含于
"""
交集
set1 & set2 #返回两个集合的交集
set.intersection(set1,set2,...) #返回集合的交集，set可以用set1,set2,...替代
set1.intersection_update(set2,set3,...) #在原始的集合set1上移除不重叠的元素，即set1变成这些集合的交集
并集
set1 | set2 #返回两个集合的并集
set.union(set1,set2,...) #返回集合的并集,set可以用set1,set2,...替代
差集
set1-set2 #返回集合差集
set2-set1
set1.difference(set2) #返回集合的差集
set2.difference(set1)
set1.difference_update(set2) #set1变成set1-set2
set2.difference_update(set1)
异或
set1 ^ set2 #返回集合的异或
set1.symmetric_difference(set2)
set1.symmetric_difference_update(set2) #set1为set1 ^ set2
包含于
set1 <= set2 #判断set1是否为set2的子集
set1.issubset(s2)
包含
set1 >= set2 #判断set1是否包含set2
set1.issuperset(set2)
判断是否不相交
set1.isdisjoint(set2)
len(set) #返回元素个数
in ,not in 判断集合是否包含某元素
5.不可变集合（frozenset）
\quad
python提供了不能改变元素的集合版本，即不能增加或删除元素，不过frozenset仍然可以进行集合操作，只是不能用带update的方法。
frozenset(iterable) #返回一个不可变集合
二、数据类型转换
获取类型信息
1.type（object）
给变量赋值后，它指向的对象就被创建，并在内存中分配了内存空间，函数type()可以判断对象的类型，不同的类型之间也许可以进行数据类型转换，见下。
a=12
print(type(a))
a=2.3
print(type(a))
a='sad'
print(type(a))
#输出：
<class 'int'>
<class 'float'>
<class 'str'>
2.isinstance(object，classinfo)
判断对象object是否是classinfo类型
注意：
1.type() 不会认为子类是一种父类类型，不考虑继承关系。
2. isinstance() 会认为子类是一种父类类型，考虑继承关系。
a、转换成整数
int(x)
x为字符串，字符串内容为数值（且不是浮点数值）‘1.23’转不了
x为浮点数，则返回整数部分
x为布尔类型，True则返回1，False则返回0
b、转化为浮点数
float(x)
字符串x内容为数值型
x为数值型
c、转化为字符串
str(x)
d、转化为布尔类型
bool(x)
x为数值型数据，非0的返回True，0返回False
x为字符串，当字符串不是空的，则返回True，否则False
x为列表，元组，字典，只要不为空，就返回True，否则返回False
#为False：
bool(0)
bool(0.0)
bool('')
bool("")
bool(())
bool([])
bool({})
三、变量命名规范
– 只能包含字母，数字，下划线。且以字母或下划开头
– 不能将Python关键字（保留字）和函数名用作变量名
– 遵循简短+具有描述性（见名知意）
– 慎用小写字母l和大写字母O
– 变量名小写
1677
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
