Python基础知识篇——变量与数据类型_python int float 是否继承某种公用类型

一、数据类型

计算机里所有的数据都可以看作对象，变量在程序中起到指向数据对象的作用。
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类型

#就近匹配
"'...'"   # √
'"..."'   # √
""...""   #×
''...''   #×

1
2
3
4
5
6

操作：

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

复合数据类型

可以存放多种类型元素的容器称为复合数据类型。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] #返回反向的列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

2.tuple（元组）

列表非常适合用于存储运行期间可能变化的数据集，列表是可以修改的。但我们有时需要创建一系列不可修改的元素，元组可以满足这种需求。

元组是用圆括号()定义的，可以用索引访问元素，可遍历，不可以修改元素。只能修改元组变量的指向。

#元组若元素只有一个的话，需要在元素后面加一个逗号
print(type((1)))  #type(数据)返回数据的类型
print(type((1,)))

#输出：
<class 'int'>
<class 'tuple'>

1
2
3
4
5
6
7
8

!!!序列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是指向同一个列表，浅复制
1
2
3
4
5
6
7
8
9
10
11

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()转换输出列表，如果各个迭代器元素个数不一样，则返回的列表长度与最短的对象一致，利用*操作符可以将元组解压为列表。
1
2
3
4
5
6
7
8
9
10
11
12

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

判断方法

操作

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}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

嵌套

#字典列表，列表的每一个元素都为字典
[{},{},{},....]

#在字典中存储列表，一个键有多个值时，可以用列表存储，对于值需要遍历得到
{key:[],....}

#在字典中存储字典
{key:{},....}

1
2
3
4
5
6
7
8
9

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 判断集合是否包含某元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

5.不可变集合（frozenset）
\quad python提供了不能改变元素的集合版本，即不能增加或删除元素，不过frozenset仍然可以进行集合操作，只是不能用带update的方法。

frozenset(iterable) #返回一个不可变集合
1

二、数据类型转换

获取类型信息
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'>
1
2
3
4
5
6
7
8
9
10
11

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({})
1
2
3
4
5
6
7
8

---

三、变量命名规范

– 只能包含字母，数字，下划线。且以字母或下划开头
– 不能将Python关键字（保留字）和函数名用作变量名
– 遵循简短+具有描述性（见名知意）
– 慎用小写字母l和大写字母O
– 变量名小写