数据类型

数据类型

1.整形（int）

Python中的整形用int表示。

• python2中
  • 在32位机器上，整数的位数为32位，取值范围为-231_{231-1，即-2147483648}2147483647
  • 在64位机器上，整数的位数为64位，取值范围为-263_{263-1，即-9223372036854775808}9223372036854775807
  • 超出长度之后就会变为long类型
• python3中
  • 只有int类型没有long类型，所以数字都是int类型

#注意：在python2中使用除法时，只能保留整数位，如果想要保留小数位，要先导入一个模块
form __future__ import division
value = 3/2
print(value)

2.布尔值（bool）

在python中，True和False都是关键字，表示布尔值。布尔类型可以用来控制程序的流程（例如判断某个条件是否成立）

• 布尔类型的特点
  • 只有两个值，True/False
  • bool是int的子类，因此True等价与1，False等价于0
  • 可以与其他数据类型进行转换
    • 布尔类型转换为整形 int(True) /int(False)
    • 布尔类型转化为字符串str(True)/str(False)
    • 整形转换为布尔类型bool(0)/bool(1)[注意：整形中只有0转为布尔值是False，其他都是True]
    • 字符串转换为布尔类型bool("")/bool("你好")[注意：字符串中只有空字符串转为布尔值是False，其他都是True]

a = int(True)					# 1
b = int(False)					# 0
c = str(True)					# True
d = str(False)					# False
e = bool(0)						# False
f = bool(1)						# True
g = bool("")					# False
h = bool("你好")				   # True
print(a,b,c,d,e,f,g,h)

执行结果：
1 0 True False False True False True

3.字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。创建字符串很简单，只要为变量分配一个值即可。例如：v1="Hello World!"

3.1 访问字符串中的值

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号 [] 来截取字符串，字符串的截取的语法格式如下：变量[头下标:尾下标]

索引值：【从左到右是以0开始依次往后】【从右到左是以-1开始依次往后】

eg:有变量str="RUNOOB"每个子字符串的索引值如下表所示

	R	U	N	O	O	B
从左往右索引值	0	1	2	3	4	5
从右往左索引值	-6	-5	-4	-3	-2	-1

• 切片操作符 [:] 是用于提取序列（如字符串、列表、元组等）的一部分。它的基本语法是 sequence[start:stop:step]（左闭右开）
  • 完整切片：str = "RUNOOB"，str[:] 返回 "RUNOOB"。
  • 指定开始和结束
    • str[start:stop]：从 start 开始到 stop 之前的所有元素。
    • 示例：str[1:4] 返回 "UNO"，因为它从索引 1 开始，到索引 4 之前结束。
  • 指定步长
    • str[start:stop:step]：从 start 开始，以 step 为间隔到 stop 之前。
    • 示例：str[0:6:2] 返回 "RNO"，因为它从索引 0 开始，每隔两个元素取一个。
  • 省略开始或结束
    • str[:stop]：从序列开始到 stop 之前。
    • str[start:]：从 start 开始到序列结束。
    • 示例：str[:3] 返回 "RUN"，str[3:] 返回 "OOB"。

3.2 字符串内置功能

使用字符串内置功能时，并不会改变原本的变量值，而是生成新的变量值

功能名	功能描述	示例
count(str)	返回 str 在 string 里面出现的次数	string = input("请输入国家：") str = "国" v3 = v1.count(str) print(v3) 执行结果： 请输入国家：国国国国发电收入发贴回收 4
capitalize()	将字符串的第一个字符转换为大写	str="runoob" new_str = str.capitalize() print(new_str) 执行结果：Runoob
len(string)	返回字符串长度	str="runoob" new_str = len(str) print(new_str) 执行结果：6
lower()	转换字符串中所有大写字符为小写.	str="ruNOOb" new_str = str.lower() print(new_str) 执行结果：runoob
upper()	转换字符串中的小写字母为大写	str="runoob" new_str = str.upper() print(new_str) 执行结果：RUNOOB
swapcase()	将字符串中大写转换为小写，小写转换为大写	str="rUNOob" new_str = str.swapcase() print(new_str) 执行结果：RunoOB
rstrip()	删除字符串末尾的空格或指定字符。	str="nihao " new_str=str.rstrip() print('--->',str,'<---') print('--->',new_str,'<---') 执行结果：---> nihao <--- ---> nihao <---
lstrip()	截掉字符串左边的空格或指定字符。	str=" nihao" new_str=str.lstrip() print('--->',str,'<---') print('--->',new_str,'<---') 执行结果：---> nihao<--- ---> nihao <---
strip([chars])	在字符串上执行 lstrip()和 rstrip()	str=" nihao " new_str=str.strip() print('--->',str,'<---') print('--->',new_str,'<---') 执行结果：---> nihao <--- ---> nihao <---
replace(old, new [, max])	把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。	eg1：str="你大爷的,你大爷的,你大爷的,你大爷的" new_str=str.replace("大爷",'**') print('--->',str,'<---') print('--->',new_str,'<---') 执行结果：---> 你大爷的,你大爷的,你大爷的,你大爷的 <--- ---> 你的,你的,你的,你的 <--- eg2：str="你大爷的,你大爷的,你大爷的,你大爷的" new_str=str.replace("大爷",'**',2) print('--->',str,'<---') print('--->',new_str,'<---') 执行结果：---> 你大爷的,你大爷的,你大爷的,你大爷的 <--- ---> 你的,你的,你大爷的,你大爷的 <---
isdecimal()	检查字符串是只包含十进制的字符，如果是返回 true，否则返回 false。	str = "runoob2016" **print** (str.isdecimal()) str = "23443434"<br/>print (str.isdecimal()) 执行结果： False True
split(str="", num=string.count(str))	以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串.会以列表的形式返回	name = "liye\n23" name_list = name.split("\n") print(name_list) 执行结果：['liye', '23']

3.3字符串格式化

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

基本语法是通过 {} 和 : 来代替以前的 % 。

format 函数可以接受不限个参数，位置可以不按顺序。位置跟索引一样，从左到右依次为0，1，2.....

##示例
>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
执行结果：'hello world'
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
执行结果：'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
执行结果：'world hello world'

##还可以引用变量
name = "菜鸟教程"
print("网站名：{}".format(name))
#执行结果：
网站名：菜鸟教程

4.列表

序列是 Python 中最基本的数据结构。Python 有 6 个序列的内置类型，但最常见的是列表和元组。

序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。列表都可以进行的操作包括索引，切片，加，乘，检查成员。如下所示：

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

4.1访问列表中的值

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

	red	green	blue	yellow	white	black
从左往右索引值	0	1	2	3	4	5
从右往左索引值	-6	-5	-4	-3	-2	-1

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )

输出结果：
red
green
blue

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

执行结果：
black
white
yellow

切片操作符 [:] 是用于提取序列（如字符串、列表、元组等）的一部分。它的基本语法是 sequence[start:stop:step]（左闭右开）

• 完整切片：list = ['red', 'green', 'blue', 'yellow', 'white', 'black']，list[:] 返回 ['red', 'green', 'blue', 'yellow', 'white', 'black']。
• 指定开始和结束
  • list[start:stop]：从 start 开始到 stop 之前的所有元素。
  • 示例：list[1:4] 返回 ['green', 'blue', 'yellow']，因为它从索引 1 开始，到索引 4 之前结束。
• 指定步长
  • list[start:stop:step]：从 start 开始，以 step 为间隔到 stop 之前。
  • 示例：list[0:6:2] 返回 ['red', 'blue', 'white']，因为它从索引 0 开始，每隔两个元素取一个。
• 省略开始或结束
  • list[:stop]：从序列开始到 stop 之前。
  • list[start:]：从 start 开始到序列结束。
  • 示例：list[:3] 返回 ['red', 'green', 'blue']，list[3:] 返回 ['yellow', 'white', 'black']。

4.2列表常用的内置功能

使用列表内置功能时，会改变原本的变量值。

功能名	功能描述	示例
list.append(obj)	在列表末尾添加新的对象	list = ['red', 'green'] list.append("Purple") print(list) 执行结果：['red', 'green', 'Purple']
list.insert(index, obj)	根据指定的索引值，将对象插入列表	list = ['red', 'green'] list.insert(1,"Purple") print(list) 执行结果：['red', 'Purple', 'green']
list.remove(obj)	移除列表中某个值的第一个匹配项（当列表中没有这个值时，执行删除动作会报错）	list = ['red', 'green','Purple'] list.remove("Purple") print(list) 执行结果：['red', 'green']
list.count(obj)	统计某个元素在列表中出现的次数	list = [1,2,1,3,1,4] print(list.count(1)) 执行结果：3
list.clear()	清空列表	list = ['red', 'green','Purple','yellow','blue'] list.clear() print(list) 执行结果：[]
list.reverse()	反向列表中元素	list = ['red', 'green','Purple','yellow','blue'] list.reverse() print(list) 执行结果：['blue', 'yellow', 'Purple', 'green', 'red']
del list[index]	根据指定索引删除对应的值	list = ['red', 'green','Purple','yellow','blue'] del list[2] print(list) 执行结果：['red', 'green', 'yellow', 'blue']

5. 元组(不可变数据)

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

##创建元组
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
##任意无符号的对象，以逗号隔开，默认为元组 【tup3】
tup3 = "a", "b", "c", "d"

5.1访问元组内的值

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素。

L = ('spam', 'Spam', 'SPAM!',1,2,3)

	spam	Spam	SPAM!	1	2	3
从左往右索引值	0	1	2	3	4	5
从右往左索引值	-6	-5	-4	-3	-2	-1

print( L[0] )
print( L[1] )
print( L[2] )
#执行结果:
spam
Spam
SPAM!

切片操作符 [:] 是用于提取序列（如字符串、列表、元组等）的一部分。它的基本语法是 sequence[start:stop:step]（左闭右开）

• 完整切片：L = ('spam', 'Spam', 'SPAM!',1,2,3)，L[:] 返回 ('spam', 'Spam', 'SPAM!', 1, 2, 3)。
• 指定开始和结束
  • L[start:stop]：从 start 开始到 stop 之前的所有元素。
  • 示例：L[1:4] 返回 ('Spam', 'SPAM!', 1)，因为它从索引 1 开始，到索引 4 之前结束。
• 指定步长
  • L[start:stop:step]：从 start 开始，以 step 为间隔到 stop 之前。
  • 示例：L[0:6:2] 返回 ('spam', 'SPAM!', 2)，因为它从索引 0 开始，每隔两个元素取一个。
• 省略开始或结束
  • L[:stop]：从序列开始到 stop 之前。
  • L[start:]：从 start 开始到序列结束。
  • 示例：L[:3] 返回 ('spam', 'Spam', 'SPAM!')，list[3:] 返回 (1, 2, 3)。

6. 字典

字典是另一种可变容器，且以键值对的方式存储任意类型对象。

字典的每个键值 key:value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中

##字典格式
d = {key1 : value1, key2 : value2 }

注意1：字典中的key是唯一的，如果重复出现相同的key，最后的一个key会替换前面的，value不唯一

test_dict = {'a':1,'b':2,'b':3}
print(test_dict['a'])
print(test_dict['b'])
#执行结果
1
3

注意2：value可以是任意数据类型，但是key必须是不可变的数据类型（如：字符串，整形，元组）

# 以下创建字典，和打印操作是非法的。运行以后会报错
test_dict = {[a]:1,'b':2,'b':3}
print(test_dict[[a]])

#报错内容如下
Traceback (most recent call last):
  File "D:\test.py\pythonProject\test.py", line 106, in <module>
    test_dict = {['a']:1,'b':2,'b':3}
TypeError: unhashable type: 'list'

6.1访问字典中的内容

在 Python 中，字典（dict）是一种无序的键-值对集合。由于字典是通过键来存取值的，而不是通过位置索引，因此字典本身不支持位置索引（像列表那样的索引）。所以需要通过key来访问字典中的值。

goods = {"title": "手机", "price": 1000}
print(goods['title'])
print(goods['price'])
#执行结果
手机
1000

6.2 字典常用的内置功能

功能名	功能描述	示例
dict.clear()	删除字典内所有元素	test_dict = {'a':1,'b':2,'b':3}<br/>test_dict.clear()<br/>print(test_dict) 执行结果：{}
dict.copy()	返回一个字典的浅复制	test_dict = {'a':1,'b':[2,3]} b = test_dict.copy() test_dict['a'] = 2 print(test_dict) print(b) 执行结果：{'a': 2, 'b': [2, 3]}<br/>{'a': 1, 'b': [2, 3]}
dict.get(key)	返回指定键的值，如果值不在字典中返回default值(default=None)	test_dict = {'a':1,'b':[2,3]} b = test_dict.get('0') c = test_dict.get('a') print(b) print(c) 执行结果：None 1
dict.items()	以列表返回可遍历的(键, 值) 元组数组	test_dict = {'a':1,'b':[2,3]}<br/>b = test_dict.items()<br/>print(b) 执行结果：[('a', 1), ('b', [2, 3])]
dict.keys()	以列表返回可遍历的键 元组数组
dict.values()	以列表返回可遍历的值 元组数组