02_Python基本数据类型

一、什么是数据

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

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

二、什么是数据类型

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

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

Python中的数据类型

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

Python中类型转换

int  ->  str  和 int  ->  bool

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

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

int与str、bool转换

str  ->  int  和  str  ->  bool

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

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

str与int、bool转换

bool -> int  和 bool -> str

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

 i = int(True)
 print(i)  #

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

bool与int、str转换

三、Python的数据类型

整形（int）

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

 #bit_length() 当十进制用二进制表示时，最少使用的位数
 i =
 print(i.bit_length())   #     2位
 print(().bit_length()) #   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 = ''
 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'))

str — method

四、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)

for-循环

五、元组（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)

Tuple - method

六、列表（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,'') #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)

list - method

删（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)

list - method

改

 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]  

list - method

查

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

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

list - method

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

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())

list - other method

七、字典(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')) #

 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])

dict - method

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

#获取所有的键(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])