python基本数,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))# 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，如下：

<

>

<=

>=

==

!=