02_Python基本数据类型

一、什么是数据

数据是描述客观事物的字符（比如95，不同的语义可表示成绩或体重），是计算机可以操作的对象，能够被计算机识别并输入给计算机处理的符号集合。

数据不仅仅包含整形，还包括图像、音乐、视频等非数值类型。

二、什么是数据类型

变量是存储在计算机内存中的数据，这就意味着在创建变量的时候会在内存中开辟一块内存空间。

变量的数据类型决定了如何将这些值存储到计算机内存中。不同的变量使用不同的类型的数据去表示

Python中的数据类型

• 整型(int)
• 布尔型(bool)
• 字符串(str)
• 元组(tuple)
• 列表(list)
• 字典(dict)
• 集合(set)

Python中类型转换

int  ->  str  和 int  ->  bool

1.int 转 str
str(666)
str1 = '666'

2.int 转 bool
非零即真，零表示假

str  ->  int  和  str  ->  bool

#str -> int 前提是字符串全是由数字组成的
i = int('666')

#str -> bool  非空为真，空字符串为假。由空格组成的字符串为真
str='' #空字符串为假
str='   ' #非空为真

bool -> int  和 bool -> str

#bool与int
i = int(True)
print(i)   #1

i = int(True)
print(i)  #0


#bool 与 str 
#用引号引起来即可 ，实际应用不是很多

 

三、Python的数据类型

整形（int）

Python可以处理任意大小的整数，它们的表示方法和数学中一摸一样，主要功能是用来运算。

#bit_length() 当十进制用二进制表示时，最少使用的位数
i = 3
print(i.bit_length())   # 0000 0011   2位
print((4).bit_length()) # 0000 0100 3位

布尔型（bool）

真 : 1 True.

假:  0 False. 

字符串（str）

字符串的索引

 索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。

a = "ABCDEFGHRGK"
print(a[0]) #A
print(a[1]) #B
print(a[2]) #C
print(a[3]) #D
print(a[4]) #E

字符串的切片

字符串的截取就是索引：索引（索引：索引：步长）之间的距离，截取字符串的一段，形成一个新的字符串，原则：顾头不顾尾 。 倒叙取必须加负号。

a = "ABCDEFGHRGK"
print(a[0:3])#截取ABC
print(a[-3:])#截取RGK
print(a[3:])#截取D~K
print(a[0:7:2])#截取A C E G
print(a[-1:-7:-2])#截取K R G  倒叙取，必须加负号

字符串的常用方法

str1 = 'String Operations'
#1.  只首字母大写，其他字符全小写
print(str1.capitalize())
#2.  大小写反转
print(str1.swapcase())
#3.  被非字母割开的部分，首字母大写，其他字符小写
print(str1.title())
#4.  全部变成大写  实际应用：验证码
print(str1.upper())
#5.  全部变成小写
print(str1.lower())
#6.  1.返回长度为width的字符串，并使得自身居中。 2. 填充字符
print(str1.center(20,'*'))
#7.  碰到tab键，给你填充到8个。
print(str1.expandtabs())
#8.  返回在片段s[start:end]内找到子串sub的字符串中的最低索引，否则返回-1
print(str1.find('ring'))
#9.  判断字符串是否以xxx为开头
print(str1.startswith('str'))
#10. 判断字符串是否以xxx为结尾
print(str1.endswith('tions'))
#11. 去除字符串前后的空格和换行符，tab键 任意设定的字符  ******   实际应用：密码输入
print(str1.strip())
#12. strip 是可迭代的，是否在前后端，除非被挡着，不管顺序，不管整体
s1 = "http://www.baidu.com"
print(str1.strip("htp:/"))
#13. 只去除前面空格，换行符，tab键
print(str1.lstrip())
#14. 只去除后面空格，换行符，tab键
print(str1.rstrip())
#15. 字符串切割 ： str -> list方法；还可以控制切割次数以及按那个字符切割
print(str1.split())
#16. 替换某些元素
print(str1.replace('string','str'))
#17. 计算某些元素出现的次数
print(str1.count('i'))
#18. 计算字符串长度
print(len(str1))
#19. 判断是否由 字符或数字组成，由字母组成，由数字组成
s1 = 'Python'
s2 = 'Python123'
s3 = '123456'
print(s1.isalpha())   #所有字符都是字母
print(s1.isalnum())   #字符串中的所有字符都是字母数字且至少有一个字符
print(s1.isdigit())   #所有字符都是数字 为True
#10. format的三种格式化方式
print("我叫{name},今年{age}岁,爱好{hobby}".format(name = '短毛兔',age=22,hobby='Python'))
print("我叫{0},今年{1}岁,爱好{2}".format('短毛兔',22,'Python'))
print("我叫{0},今年{1}岁,爱好{2},我正在学习{2}".format('短毛兔',22,'Python'))

四、for循环

用户按照顺序循环可迭代对象的内容。Python中for循环，可以遍历任何序列项目，如一个列表一个字符串。

for循环---语法

for iterating_var in sequence:
   statements(s)

 

 1 str1 = 'Python is an easy to learn.'
 2 
 3 for i in str1:
 4     print(i)
 5 
 6
 7 fruits = ('banana','apple','mango')
 8 
 9  for i in fruits:
10     print("水果 ： " + i)

五、元组（Tuple）

元组被称为只读列表，即数据可以被查询，但不能被修改，可以被看作只读列表。所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）

元组常用方法

tup1 = ('Google', 'Runoob', 1997, 2000,[1,2,3])
#1.元组的遍历
for i in tup1:
    print(i)

#2.元组的长度
print(len(tup1))

#3.统计o在tup1中出现的次数
print(tup1.count(0))

#4.元组不能被修改，元组的儿子不能被修改，元组的孙子如果为列表、字典的话可以修改
#元组中列表中的2改为0
tup1[4][1] = 0
print(tup1)

六、列表（List）

列表是Python中最基本的数据结构。序列中的每个元素都分配一个索引，第一个索引是0，第二个索引是1，依此类推。

对列表进行的操作包括索引、切片、尾部追加、任意位置插入、插入一个迭代元素、根据索引删除元素、删除指定元素、清空列表、删除列表、修改列表元素、查询元素索引。

以及常用的操作：获取列表长度、统计某个字符出现的次数、列表排序等。

增（append、insert、extend）

append 　：  在列表最后追加元素

insert　　： 任意位置插入元素

extend　 ： 在列表末尾一次性追加另一个序列中的多个值，操作的是迭代元素

list1 = ['a','b','zhangsan','lisi',5,6,7,True,False,True]

#1.list中元素的类型
print(list1[7],type(list1[7])) # list1[7] True <class 'bool'>
#2.追加
list1.append('end') #append object to end

#3.插入
list1.insert(2,'2') #insert object before index
print(list1[2],type(list1[2]))  #<class 'str'>

#4.迭代插入 会把 迭代体 拆成一个个插入,符号也
list1.extend('1,2,3')#['a', 'b', 'zhangsan', 'lisi', 5, 6, 7, True, False, True, '1', ',', '2', ',', '3']
list1.extend()
print(list1)

删（pop、remove、clear、del）

pop　　  ：删除指定索引位置的元素；默认删除最后一个。根据索引删元素，返回被删除的值。

remove   ：删除列表中某个元素，没有返回值。

clear　　：清空列表，内存中不回收列表的资源

del　　   ：删除列表，释放列表所占用的资源；可以按照索引删、切片删

list1 = [1,2,3,4,5,6,7,8,9,10]
#1.pop删除指定索引位置元素
list1.pop()  #  result = [1, 2, 3, 4, 5, 6, 7, 8, 9]

#2.remove删除元素
list1.remove(9)  # result = [1, 2, 3, 4, 5, 6, 7, 8, 10]

#3.clear 清空链表
list1.clear()   # result = []

#4.del 删除链表
del list1    #   再打印list1会报错
del list1[5]  # result = [1, 2, 3, 4, 5, 7, 8, 9, 10]
del list1[1:11:2]  #result = [1, 3, 5, 7, 9]

print(list1)

改

list1 = [1,2,3,4,5,6,7,8,9,10]
#1.按照索引改
#list1[0] = '1'

#2.按照切片更改
#list1[0:1] = ['list','num']    #['list', 'num', 2, 3, 4, 5, 6, 7, 8, 9, 10]
#list1[0:2] = '努力'            #['努', '力', 3, 4, 5, 6, 7, 8, 9, 10]
#list1[0:1] = '努力'            #['努', '力', 2, 3, 4, 5, 6, 7, 8, 9, 10]
list1[0:2] = '强'              #['强', 3, 4, 5, 6, 7, 8, 9, 10]  

查

l1 = [1,3,6,8,7,4,2,9,10]
#查 按切片,按索引去查
l1[0]
l1[0:3]


#for 循环查
for i in l1:
    print(i)

其他操作：获取长度、统计某个元素出现的次数、查找元素，返回元素第一次出现的索引、排序、倒置

l2 = [1,3,6,8,7,4,2,9,10]
# len 长度
print(len(l1))

#count 出现次数
print(l1.count(True))

#index 通过元素找索引
print(l2.index('taibai'))

#sort 从小到大
print(l2.sort())

#sort(reverse)  从大到小
print(l2.sort(reversed = True))

#倒置
print(l2.reverse())

七、字典(dict)

 字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

字典能存放大量的类型，且关联性较强，可存放任意类型。

字典的常用操作（增、删、改、查）

dic  = {'name':'Python','version':3.6,'code':3}

# 1.增
#1. 添加，如果存在就覆盖，如果不存在就增加
dic['local'];  #这样写错误 ，如果没有value的话，就 等于None
dic['local']  = None;
dic['local'] = 'US'
print(dic)

#1.1 添加，如果存在就忽略，如果不存在就添加
dic.setdefault('name','Python3')  #dic中存在name，所以无操作
dic.setdefault('name1','Python3')
print(dic)

# 2.删
#2. 删除 pop  通过键删除，返回删除键的值
print(dic.pop('code')) #3

print(dic.pop('code')) #error 如果删除不存在的键会报错
#2.1 pop 的第二种用法，两个参数
print(dic.pop('code','没有此键'))

#2.2 clear 清空dic
dic.clear()
print(dic)  #{}

#2.3 del 删除dic
del dic
print(dic) #error

#2.4  根据键来删除，没有返回值
del dic['name']
print(dic)  #  {'version': 3.6, 'code': 3}

#2.5 随机删除  返回值元组，默认删除最后一个
dic.popitem()
print(dic)  #{'name': 'Python', 'version': 3.6}


#3.改
#3.1 dic[key]  如果key存在，就覆盖。不存在的话，就添加
dic['name'] = 'Java'
print(dic)
#3.2 dic.update() 如果有相同键->覆盖，没有的添加
dic.update({'name':'JAVA'})
dic.update({'RuntimePlatform':'Win10'})
print(dic)

#4.改
#4.1 查 根据键查
print(dic['name'])  #Python
print(dic['name1']) # error   查询不存在的键会报错

#4.2 get方式查 查询不存在的键，不会报错
print(dic.get('name')) #Python
print(dic.get('name1')) #None
print(dic.get('name1','此键不存在')) #None

#4.3 for 循环查
for i in dic :
    print(i,dic[i])

字典的其他操作（获取所有的键值对、获取所有的键、获取所有的值）

#获取所有的键(key)
#1 遍历dic
for i in dic:
    print(i)

#2 通过dic.keys
for k in dic.keys():
    print(k)

#获取所有的值
#1 通过key
for i in dic:
    print(dic[i])

#通过dic.values
for v in dic.values:
    print(v)


#获取多有的键值对
#1 返回元组类型
for i in dic.items:
    print(i)

#2 返回所有键值 
for k,v in dic.items:
    print(k,v)

#3 返回所有键值
for k in dic:
    print(k,dic[k])