Python基础数据类型及其操作

1.数字 （Number）

一、数字类型：

①int 整数（整型）：

通常被称为是整型或整数，可以是正整数或负整数，不带小数点。Python3整型是没有限制大小的，可以当做long类型使用， 但实际上由于机器内存的有限，我们使用的整数是不可能无限大的。

整型的四种表现形式：

2 进 制：以’0b’开头。例如：'0b11011’表示10进制的27
8 进 制：以’0o’开头。例如：'0o33’表示10进制的27
10进制：正常显示
16进制：以’0x’开头。例如：'0x1b’表示10进制的27
各进间数字进行转换（内置函数）：

bin（i）：将i转换为2进制，以“0b”开头。

oct（i）：将i转换为8进制，以“0o”开头。

int（i）：将i转换为10进制，正常显示。

hex（i）：将i转换为16进制，以“0x”开头。

②float 浮点数：

浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

③bool----True=1,False=0
----------布尔类型：

所有标准对象均可用于布尔测试，同类型的对象之间可以比较大小。每个对象天生具有布尔True或False值。空对象,值为零的任何数字或者Null对象None的布尔值都是False。在Python3中True=1，False=0，可以和数字型进行运算。

下列对象的布尔值是False：

None；False；0（整型），0.0（浮点型）；0L（长整形）；0.0+0.0j（复数）；“”（空字符串）；[]（空列表）；（）（空元组）；{}（空字典）。

值不是上列的任何值的对象的布尔值都是True，例如non-empty,non-zero等。用户创建的类实例如果是定义了nonzero(nonzeor())或length(len())且值为0，那么它们的布尔值就是False。

④complex 复数：

复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

2.字符串（string）

字符串，用’ ’ 或者 " " 包含在内，也可以用 “” “” 来包含多行字符串
有两种索引方式：从左到右（0开始），从右到左（-1开始）
可以进行切片：str[1:],str[:],str[1:7],str[-7:-1]
元素不可变
没有单独的字符形式，只有长度为一的字符串

字符串可以包含数字、字母、中文字符、特殊符号，以及一些不可见的控制字符，如换行符和制表符
在单引号，双引号，三引号中都可以定义字符串

常用操作：

name='fadoJia'
print(name.count("a"))
# 查询字母出现的次数

number='777'
print(number.isdigit())
# 判断输入是否仅有数字组成

字符串常用方法：

字符串操作	描述
String.capitalize()	将字符串的第一个字母大写
String.count()	获得字符串中某一字符串的题目
String.find()	获得字符串中某一字符串的起始位置
String.isalnum()	检测字符串是否包含0-9
String.isalpha()	检测字符串是否包含A-Za-z
String.isdigit()	检测字符串是否仅仅包含数字
String.islower()	检测字符串是否均为小写
String.isspace()	检测字符串是否均为空白字符
String.istitle()	检测字符串是否为首字母大写
String.isupper()	检测字符串是否为大写
String.join()	连接字符串
String.lower()	将字符串全部转换为小写
String.split()	分割字符串
String.swapcese()	将字符串中大小写进行转换
String.title()	将字符串中的首字母大写

3.列表（List）

用[]表示，中间用“,”隔开，元素类型可以不相同
构建0个元素或者一个元素的元组是特殊的，tuple=()tuple=(1,)
元素不可变
可以用+链接，也可以用索引切片

定义：
列表是有序的队列，最外层用中括号括起来，列表内的数据类型不限，每个元素之间用逗号进行分隔

name=['fado','herry']
print(name)

查找元素所在位置：

print(names.index('fado'))

统计元素出现次数：

print(names.count('fado'))

插入：

修改：

删除：

反转：

排序：

扩展：

4.集合（Set）

无需不重复的集
可以用（）来创建包含元素的集合，或者用（）来创建元素的集合
可以进行去重或者测试成员的关系
#作用：去重，关系运算，

定义：
可变类型是不可hash类型
不可变类型是可hash类型
定义集合:
集合：可以包含多个元素，用逗号分割，
集合的元素遵循三个原则：
1：每个元素必须是不可变类型(可hash，可作为字典的key)
2:没有重复的元素
3：无序
注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
#set把不同的元素集合在一起（不能相同）无序的， frozenset不可变集合，可以用for ，迭代器遍历，用in判断元素是否在集合里

l = ['zhang','wang','zhang']
s = set('alex li')
s1 = set(l)
print(s) #{' ', 'a', 'x', 'l', 'e', 'i'}
print(s1)#{'wang', 'zhang'}
print(type(s1))#<class 'set'> type表示数据的类型
 
li = [(1,2),'aa',1]
ss = set(li)
print(ss) #{(1, 2), 1, 'aa'}
ss.add(78)#增一个元素
ss.update("nmk")#增三个元素
print(ss)#{(1, 2), 1, 78, 'm', 'n', 'k', 'aa'}
ss.remove(1)#删除
aa = ss.pop()#删除，还有一个clear
 
print(set("qwer") == set("qwerewq"))#true
print(set("qwer") < set("qwer"))#false子集
a = set([1,2,3,4,5])
b = set([4,5,6,7,8])
aa = a.intersection(b)#交集
print(aa)#{4, 5}
print(a.union(b))#并集{1, 2, 3, 4, 5, 6, 7, 8}
print(a.difference(b))#差集{1, 2, 3}
print(a.symmetric_difference(b))#对称差集{1, 2, 3, 6, 7, 8}
下面写法等价于上面的，更简单
a|b #并集
a&b# 交集
a-b#差集
a^b #对称差集
 
#父级a是b的父级  >
a.issuperset(b)
#子集  <
a.issubset(b)

5.Dictionaries（字典）

是一个无序的键值对集合
生命格式位：dic={key:value,key:value},dic={},dic={key=value,key=value}

定义：字典由键和对应值（key-value）组成，键与值之间用冒号：隔开，每对用逗号隔开

info = {
    'stu01': "fado",
    'stu02': "lisa",
    'stu03': "peter",
    'stu04': "John"
}
print (info)  #不一定顺序打印

查询：

print (info["stu01"])

print (info.get("stu06"))  #用于不确定值是否存在时，不存在，返回 None

修改：

info["stu01"] = "fado"
print (info)
info["stu05"] = "lisa"  #查找不到则添加新的语句
print(info)

删除：

del info["stu05"]   #方法一
print(info)
del info   #删除整个表

info.pop("stu04")   #方法二
print(info)

其他操作：

 print(info.values())   #打印所有的值

info.setdefault("stu03","Wangming")     #先查询stu03的值，若没有，添加进去，否则，不做任何操作
print (info)

a.update(b)   #合并，有重复的更新
print(a)

print(info.items())   #字典转列表

循环：

 for i in info:
    print(i, info[i])  #i-->key; info[i]-->valus

嵌套及操作：

info = {
    "stu01":{"姓名":"张华",
              "年龄":"19",
              "专业":"计算机"},
    "stu02":{"姓名":"李明",
              "年龄":"20",
              "专业":"计算机"},
    "stu03": {"姓名": "谢娜",
              "年龄": "19",
              "专业": "网络"},
    "stu04": {"姓名": "王婷",
              "年龄": "20",
              "专业": "网络"}

}
info["stu01"]["专业"] = "通信"
print (info)

#python中唯一的映射类型------字典（无序）根据hash算法存放
#id()#打印内存地址
#不可变类型：整形，字符串，元组
#可变类型：列表，字典
#字典的键必须为不可变类型，因为它是唯一的
dict={'name':'zhangqiye','age':'11','sex':'nan'}
print(dict['name'])
dict1={}
dict1['name']='sanpang' #可增加，可修改
 
dict1.setdefault('name','wangwu')#只可增加，修改不了,有返回值（返回字典中的值）
dict1.setdefault('age','11')
print(dict.keys()) #dict_keys(['name', 'age', 'sex'])
print(dict.values()) #dict_values(['zhangqiye', '11', 'nan'])
print(dict.items()) #dict_items([('name', 'zhangqiye'), ('age', '11'), ('sex', 'nan')])
dict2={1:2,22:33}
dict1.update(dict2)
print(dict1)#{'name': 'sanpang', 'age': '11', 1: 2, 22: 33}
#删除  del  clear  pop
del dict['name']
#dict.pop('name')#有返回值
dict.clear()
#dict.popitem()#随机删除

6.tuple（元组）

定义：元组和列表类似，也是存一组数。但不同之处在于，元组一旦创建，便不能修改。元组使用小括号，列表使用中括号。

只有两种查询的方法，一个是count，一个是index

元组相关操作:

查询
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
 
print "tup1[0]: ", tup1[0]
print "tup2[1:5]: ", tup2[1:5]
 
不允许修改元组，但我们可以对元组进行连接组合，如下实例:
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
 
# 创建一个新的元组
tup3 = tup1 + tup2;
print tup3;
 
删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
tup = ('physics', 'chemistry', 1997, 2000);
del tup;

运算符：

算术运算符

运算符包括加减乘除，乘方，取余等运算符，在计算的时候，如果有浮点数，那么会将整数自动转换为浮点数进行运算，在优先级中，乘方的优先级最高，可以使用括号来进行修改其优先级。符号分别为:+，-，*，/,%,浮点除法为//

逻辑运算符

And	or
not

使用逻辑运算符可以将任意表达式连接在一起，并得到一个布尔值。

如下例子是可以使用的：

3<4<5

True

6>=5>=4

True
可以使用这种形式来表示and的条件。在进行求值得时候，从左到右的顺序执行。

在进行条件的判断的时候，注意适当的使用括号来增加代码的可读性。

比较运算符

比较运算符根据表达式的值为真假，从而返回布尔值True或者False，如下：

<	>
<=	>=
==	!=