python的数据类型
Python的数据类型
字符串
字符串操作：
* 字符串的定义
str = “abc.123_中文_utf-8”
* 字符串合并
>>> str1="abc"
>>> str2="utf-8"
>>> num1=123
>>> str1 + num1 + str2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly
# 可以看到不同类型的数据是不能合并在一起的，我们把类型转换一下试试
>>> str1 + str(num1) + str2
'abc123utf-8'
# 合并成功
* 字符串去除空字符
# 定义一个字符串，我们可以看到字符串左侧右侧分别有空字符
>>> raw_str = " abc "
>>> print("|" + raw_str + "|")
| abc |
# 去除空字符
>>> remove_null_character = raw_str.strip()
>>> print("|" + remove_null_character + "|")
|abc|
# 去除字符串左侧空字符
>>> remove_left_null_character = raw_str.lstrip()
>>> print("|" + remove_left_null_character + "|")
|abc |
# 去除字符串右侧空字符
>>> remove_right_null_character = raw_str.rstrip()
>>> print("|" + remove_right_null_character + "|")
| abc|
* 字符串分割
# 定义一个字符串，字符串中有几个空字符隔开了几个字段
>>> raw_str = "abc 123 xyz !@#"
>>> print(raw_str)
abc 123 xyz !@#
# 用法: raw_str.split("分割的关键字")
>>> cut_str = raw_str.split(" ")
>>> print(cut_str)
['abc', '123', 'xyz', '!@#']
# 从左侧分割字符串用法: raw_str.split("分割的关键字",分割几个字段)
>>> cut_str_1_field = raw_str.split(" ",1)
>>> print(cut_str_1_field)
['abc', '123 xyz !@#']
>>> cut_str_2_field = raw_str.split(" ",2)
>>> print(cut_str_2_field)
['abc', '123', 'xyz !@#']
>>>
# 从右侧分割字符串用法: raw_str.rsplit("分割的关键字",分割几个字段)
>>> cut_str_right_1_field = raw_str.rsplit(" ",1)
>>> print(cut_str_right_1_field)
['abc 123 xyz', '!@#']
* 字符串的索引、切片#定义一个7位的字符
>>> var_str = "abcdefg" # 取字符串的第二个字符 >>> var_str[1] 'b' # 取字符串的第一个字符 >>> var_str[0] 'a' # 取字符串的第2-4个字符 >>> var_str[1:4] 'bcd' # 取字符串的第2-6个字符，每隔3个显示一个（步长为3） >>> var_str[1:6:3] 'be'
# 取数据库的第0-4个字符
>>> var_str[:4]
'abcd'
# 取数据库的第5个以后的所以字符
>>> var_str[4:]
'efg'
# 取数据库的所有字符，隔一个取一个
>>> var_str[::2]
'aceg'
*取字符串长度
# 定义一个字符串 >>> var_str = "abcdefg" # 获取字符串的长度 >>> len(var_str) 7
数字
1. 整形
* 定义
a=123 a=int(123)
* 转换
# 定义变量str值为字符串类型123
>>> str = str(123)
>>> type(str)
<class 'str'>
# 定义变量num，将str的值强制转换为int类型
>>> num = int(str)
# 可以看到变量类型为int，值为123
>>> type(num)
<class 'int'>
>>> print(num)
123
2. 浮点型
* 定义
float = 123.4 float = float(123.4)
* 转换
# 定义变量i 赋值int类型123
>>> i = 123
>>> type(i)
<class 'int'>
# 强制转换为浮点型
>>> f = float(i)
>>> type(f)
<class 'float'>
>>> print(f)
123.0
布尔型
True 1 真
False 0 假
* 定义
bool = True
bool = False
* 转换
1. 数字转换，只有0是False，其他True
2. 字符串， 只有""是False，其他True
3. 待续...
列表
列表操作：
- 创建
list = [12,12.3,"abc",["a","b"],("x","y"),{"key":"value"},bool(True)]
- 长度
>>> len(list)
7
- 索引
>>> list = [12,12.3,"abc",["a","b"],("x","y"),{"key":"value"},bool(True)]
>>> list[2]
'abc'
>>> list[3]
['a', 'b']
- 切片
# 定义一个列表list_1
>>> list_1 = ["aaa","bbb","ccc","ddd","eee"]
# 用法与字符串切片类似，具体原理见下图
>>> list_1[2:0:-1]
['ccc', 'bbb']
- 追加
# 定义一个列表list_1
>>> list_1 = ["aaa","bbb","ccc","ddd","eee"]
# 在列表list_1中追加一个新元素
>>> list.append("new_element")
>>> print(list_1)
['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'new_element']
- 插入
# 有一个列表list_1如下：
>>> print(list_1)
['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'new_element']
# 在列表的第一个位置插入一个新元素
>>> list_1.insert(1,"insert_element")
>>> print(list_1)
['aaa', 'insert_element', 'bbb', 'ccc', 'ddd', 'eee', 'new_element']
>>>
- 删除
# 有这样一个列表list_1如下：
>>> print(list_1)
['aaa', 'new_element', 'bbb', 'ccc', 'ddd', 'eee', 'new_element']
# 删除为“new_element”的元素
>>> list_1.remove("new_element")
>>> print(list_1)
['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'new_element']
# 可以看到remove只会从左到右查找到第一个元素并删除，后面的不做任何处理
- 更新元素
# 有这样一个列表list_1如下
>>> print(list_1)
['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'new_element']
# 修改列表的最后一个（list_1[-1]）元素为fff
>>> list_1[-1] = "fff"
>>> print(list_1)
['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff']
- 判断列表中是否存在
# 有这样一个列表list-1如下：
>>> print(list_1)
['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff']
# 判断列表list_1里面是否包含“ddd”元素
>>> if "ddd" in list_1:
... print('element "ddd" in list list_1')
... else:
... print('There is no element "ddd" in list list_1')
...
element "ddd" in list list_1
- 循环
# 有这样一个列表list_1如下
>>> print(list_1)
['aaa', 'bbb', 'ccc', 'ddd', 'eee', 'fff']
# 下面我们用循环遍历这个列表，并打印结果
>>> for element in list_1:
... print("list_1 have %s" %element)
...
# 输出如下
list_1 have aaa
list_1 have bbb
list_1 have ccc
list_1 have ddd
list_1 have eee
list_1 have fff
元组
- 元组创建
# 方法一：
>>> tup = (12,12.3,"abc",["a","b"],("x","y"),{"key":"value"},bool(True))
>>> type(tup)
<class 'tuple'>
# 方法二：
>>> tup = tuple(( 12,12.3,"abc",["a","b"],("x","y"),{"key":"value"},bool(True)
))
>>> type(tup)
<class 'tuple'>
# 方法三：
>>> tup = 12,12.3,"abc",["a","b"],("x","y"),{"key":"value"},bool(True)
>>> type(tup)
<class 'tuple'>
- 元组操作
-
-
- 索引
- 切片
- 循环
- 长度
- 包含
-
* 以上操作与列表的操作相同，这里不再单独阐述，值得注意的是元组的一些特性，如下：
- 元组的特性（不可修改性）
# 创建元组
>>> tup = (12,12.3,"abc",["a","b"],("x","y"),{"key":"value"},bool(True))
# 尝试修改元组中的数据，可以看到元组中的元素是不允许修改的
>>> tup[0] = "t"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
# 元组是不可修改的，不止元素，元组本身也是不可修改的
字典
- 字典的创建
# 创建字典
>>> dict = {"key":"value","key1":"value","key2":"value1","key3":"value2"}
# 查看类型
>>> type(dict)
<class 'dict'>
# key是有唯一性的 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行
- 字典操作：
-- 索引
# 创建字典
>>> dict = {"key":"value","key-1":"value-1","key-2":"value-2","key-3":"value-3"}
# 查询字典中key "key-1" 对应的值
>>> dict["key-1"]
'value-1'
-- 修改
# 定义一个字典
>>> dict = {"key":"value","key-1":"value-1","key-2":"value-2","key-3":"value-3"}
# key的值为value
>>> dict["key"]
'value'
# 修改键key的值为new_value
>>> dict["key"] = "new_value"
# 字典key对应值已经修改
>>> dict
{'key': 'new_value', 'key-1': 'value-1', 'key-2': 'value-2', 'key-3': 'value-3'}
-- 增加
# 字典如下
{'key': 'new_value', 'key-1': 'value-1', 'key-2': 'value-2', 'key-3': 'value-3'}
# 添加一个新元素new_key:new_key_value
>>> dict["new_key"] = "new_key_value"
# new_key已经添加到字典
>>> dict
{'key': 'new_value', 'key-1': 'value-1', 'key-2': 'value-2', 'key-3': 'value-3', 'new_key': 'new_key_value'}
-- 删除
# 创建一个字典d
>>> d = {"key":"value","key-1":"value-1","key-2":"value-2","key-3":"value-3"}
# 删除字典里指定元素
>>> del d["key-2"]
>>> d
{'key': 'value', 'key-1': 'value-1', 'key-3': 'value-3'}
# 清空字典所有元素
>>> d.clear()
>>> d
{}
# 删除字典
>>> del d
>>> d
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'd' is not defined
-- 循环
# 定义字典d
>>> d = {"key":"value","key-1":"value-1","key-2":"value-2","key-3":"value-3"}
# 循环遍历字典的key
>>> for key in d.keys():
... print(key)
...
key
key-1
key-2
key-3
# 循环遍历字典的value
>>> for value in d.values():
... print(value)
...
value
value-1
value-2
value-3
# 循环遍历字典的key和value
>>> for key,value in d.items():
... print("key: %s,value: %s" %(key,value))
...
key: key,value: value
key: key-1,value: value-1
key: key-2,value: value-2
key: key-3,value: value-3
# dict.items()是以元组形式返回的
>>> for item in d.items():
... print(item)
...
('key', 'value')
('key-1', 'value-1')
('key-2', 'value-2')
('key-3', 'value-3')
-- 长度
# 创建字典d
>>> d = {"key":"value","key-1":"value-1","key-2":"value-2","key-3":"value-3"}
# 查看字典长度
>>> len(d)
4
查询数据类型
type()查询字符类型：
type()用法:
type(variable)
# 有一个列表list如下：
>>> print(list)
[12, 12.3, 'abc', ['a', 'b'], ('x', 'y'), {'key': 'value'}, True, 'new_element']
# 定义一个计数器记录元素位置
>>> i = 0
# 下面我们来遍历这个列表，并查询每个元素的数据类型
>>> for element in list:
... i += 1
... print("列表的第 %d 个元素 %s ，数据类型为 %s" %(i,element,type(element)))
...
# 结果如下：
列表的第 1 个元素 12 ，数据类型为 <class 'int'>
列表的第 2 个元素 12.3 ，数据类型为 <class 'float'>
列表的第 3 个元素 abc ，数据类型为 <class 'str'>
列表的第 4 个元素 ['a', 'b'] ，数据类型为 <class 'list'>
列表的第 5 个元素 ('x', 'y') ，数据类型为 <class 'tuple'>
列表的第 6 个元素 {'key': 'value'} ，数据类型为 <class 'dict'>
列表的第 7 个元素 True ，数据类型为 <class 'bool'>
列表的第 8 个元素 new_element ，数据类型为 <class 'str'>
