Python数据类型

1. 数据类型

1.1 什么是数据类型

数据类型是一个值的集合和定义在此集合上一组操作（通常是增删改查或者操作读写的方法）的总称。

数据类型又分：

• 原子类型：比如编程语言的int，double，char，byte，boolean。
• 复合类型：又称结构类型，通过原子类型封装的更复杂的类型，比如面向对象语言里面的类

python 中常用数据类型包括: int、float,str、list、dict、bool、tuple、set

2 整型:int

整型:没有小数部分的数据，即整数。在计算机中使用int表示。

示例:

>>> num = 9
>>> type(num)
<class 'int'>

2.1 int()函数

int()函数主要是类型转换。int()在做类型转换的时候 只能转换纯数字

>>> num = '123'
>>> type(num)
<class 'str'>
>>> num = int(num)
>>> type(num)     
<class 'int'>

int()还可以做进制数转换

>>> bin(10)  #把十进制10转成二进制
'0b1010'
>>> oct(10)	#把十进制10转成八进制
'0o12'
>>> hex(10)	#把十进制10转成十六进制
'0xa'

#利用int()把二进制，八进制，十六进制转换十进制
>>> int('0b1010', 2)  #把二进制转换十进制
10
>>> int('0o12', 8)  #把八进制转换十进制
10
>>> int('0xa', 16)  #把十六进制转换十进制
10

3 浮点型:float

浮点型:简单来说就是表示带有小数的数据,即小数。

示例:

>>> salary = 30000.5
>>> type(salary)
<class 'float'>

3.1 float()函数

float()做类型转换。

>>> fnum = '123.456'
>>> type(fnum)
<class 'str'>
>>> fnum = float(fnum)
>>> type(fnum)        
<class 'float'>

>>> num = 123
>>> type(num)
<class 'int'>
>>> num = float(num)
>>> type(num)       
<class 'float'>
>>> num
123.0

4. 字符串:str

字符串:是由零个或多个字符组成的有限序列.

定义字符串:

• 单引号: '允许包含有 "双" 引号'
• 双引号: "允许包含有 '单' 引号"。
• 三重引号: '''三重单引号''', """三重双引号"""

使用三重引号的字符串可以跨越多行 —— 其中所有的空白字符都将包含在该字符串字面值中.

示例:

1. 单引号
name  = 'Hans'
2. 双引号
name = "Hans"
3. 三重引号
name = '''Hans'''
name = """Hans"""

>>> name = 'Hans'
>>> type(name)
<class 'str'>

>>> info = "My name is 'Hans'"
>>> print(info)
My name is 'Hans'
>>> type(info)
<class 'str'>

>>> pythonzen = """
... Beautiful is better than ugly.
... Explicit is better than implicit.
... Simple is better than complex.
... """
>>> print(pythonzen) 

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.

字符串可以使用 + 和* 运算符，
+为拼接
>>> h = "Hello"
>>> name = "'Hans"
>>> h + name
'HelloHans'
//不过不推荐使用这种方式拼接，比较消耗内存资源，可以使用join()
* n 为连接不换行打印n次
>>> name * 5
'HansHansHansHansHans'

4.1 str内置方法

1. 类型转换,任意类型都可以转成字符串类型

   >>> num = 123
   >>> type(num)
   <class 'int'>
   >>> num = str(num)  #int类型转字符串
   >>> type(num)     
   <class 'str'>
   
   >>> fnum = 123.45
   >>> type(fnum)
   <class 'float'>
   >>> fnum = str(fnum)	#float类型转字符串
   >>> type(fnum)      
   <class 'str'>
   
   >>> list1 = [1, 2, 3, 4]
   >>> list1 = str(list1) #list类型转字符串
   >>> type(list1)
   <class 'str'>
   >>> list1
   '[1, 2, 3, 4]'
   
   >>> tuple1 = (1, 2, 3, 4)
   >>> tuple1 = str(tuple1) #tuple类型转字符串
   >>> type(tuple1)
   <class 'str'>
   
   >>> dict1 = {'name':'Hans', 'age': 18}
   >>> dict1 = str(dict1)  #dict类型转字符串
   >>> type(dict1)
   <class 'str'>
   
   >>> set1 = {1, 2, 3, 4} 
   >>> set1 = str(set1)  #set类型转字符串
   >>> type(set1)      
   <class 'str'>
   

2. 基本用法

   1. 索引取值
   >>> res = "Hello World!"
   >>> res[0]  # 索引取值下标从0开始
   'H'
   2. 切片(前开后合，顾头不顾尾)
   >>> res[2:4]  #切出来下标为2到下标为4中间的数据，其中包括下标为2的，但不包括下标为4的
   'll'
   3.步长操作
   >>> res[1:8:2]
   'el o'
   4.索引支持负数
   >>> res[-1] #最后一位
   '!'
   >>> res
   'Hello World!'
   >>> res[-5:-1]  #取-5到-1的元素，从左向右，并且不包括-1
   'orld'
   
   5.统计字符串内部字符的长度
   >>> res
   'Hello World!'
   >>> len(res)  
   12
   
   6.移除字符串首尾指定的字符(strip())
   >>> name = "    hans    "
   >>> name
   '    hans    '
   >>> len(name)
   12
   >>> name = name.strip()  # 默认取掉首尾的空格
   >>> name
   'hans'
   >>> len(name)            
   4
   
   #去掉左边的空格
   >>> name = "    hans    "
   >>> name
   '    hans    '
   >>> name.lstrip()
   'hans    '
   #去掉右边的空格
   >>> name
   '    hans    '
   >>> name.rstrip()
   '    hans'
   #strip()默认去除空格，可以设置去除别的符号
   >>> name = '###Hans####' 
   >>> name
   '###Hans####'
   >>> name.strip('#')
   'Hans'
   
   示例,去除用户输入时在关键字左右的空格：
   >>> name = input("Your Name:")
   Your Name:    Hans    
   >>> name
   '    Hans    '
   >>> name = name.strip()
   >>> name
   'Hans
   
   或者：
   >>> name = input("Your Name:").strip()  #在用户输入时直接去掉空格
   Your Name:      hans         
   >>> name
   'hans'
   7.按照指定的字符切割字符串(split())
   >>> str1 = "hans 18 study" 
   >>> str1.split()       #默认以空格分隔   
   ['hans', '18', 'study']
   >>> str1 = "hans|18|study" 
   >>> str1
   'hans|18|study'
   >>> str1.split("|") #以‘|’分隔   
   ['hans', '18', 'study']
   
   >>> str1
   'hans|18|study'
   >>> str1.split("|", maxsplit=1) #只分隔一次，默认从左向右分隔
   ['hans', '18|study']
   >>> 
   
   >>> str1.rsplit("|", maxsplit=1)  #从右向左分隔，只分隔一次，
   ['hans|18', 'study']
   
   #maxsplit为最大分隔的次数
   
   

5. 列表:list

列表:列表是可变序列，通常用于存放相同类型元素的集合。

列表可以包含不同类型的元素，但一般情况下，各个元素的类型相同

创建列表:用方括号标注，逗号分隔的一组值，元素可以是任意数据类型

• 使用一对方括号来表示空列表: []
• 使用方括号，其中的项以逗号分隔: [a], [a, b, c]

示例:

>>> list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> type(list1)
<class 'list'>

利用下标(索引)可以随意取出列表中的值,下标的值从0开始。
//例如要把5取出来，由于下标从0开始，5所在的下标为4，所以:
>>> list1[4]
5
//定义一个列表，取出"second"
>>> list2 = [1, 2, 3,['A','B','C',["fist", "second"]]]
>>> list2[3][3][1]
'second'

列表类型是一个容器，它里面可以存放任意数量、任意类型的数据

6. 字典:dict

字典:用于存放具有映射关系的数据。

字典相当于保存了两组数据，其中一组数据是关键数据，被称为 key；另一组数据可通过 key 来访问，被称为 value。

字典可以通过将以逗号分隔的 键: 值 对列表包含于花括号之内来创建,value可以是任意数据类型

字典可用多种方式来创建:

• 使用花括号内以逗号分隔 键: 值 对的方式: {'jack': 4098, 'sjoerd': 4127} or {4098: 'jack', 4127: 'sjoerd'}
• 使用字典推导式: {}, {x: x ** 2 for x in range(10)}
• 使用类型构造器: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)

>>> person = {"name" : "Hans", "age" : 18, "gender" : "M", "phone" : "1234567890"}
>>> type(person)
<class 'dict'>
>>> person
{'name': 'Hans', 'age': 18, 'gender': 'M', 'phone': '1234567890'}
//字典取值使用键来取,即用key来取value.
>>> person['name']
'Hans'
>>> person['phone']
'1234567890'

练习:
定义一个字典{'name': 'Hans', 'age': 18, 'addr': ['中国', '上海', ['青浦区', 999, 602]]}，取出里数字999.
>>> person_info = {
... "name" : "Hans",
... "age" : 18,
... "addr" : ["中国","上海", ["青浦区", 999, 602]]
... }
>>> person_info['addr'][2][1]
999

7. 布尔值:bool

布尔:用于判断事物的对错 是否可行等。

布尔只有两个值:True和False.True表示真，False表示假

>>> type(True)
<class 'bool'>
>>> type(False)
<class 'bool'>

实际上bool类型是int类型的一个子类

>>> bool.__bases__
(<class 'int'>,)
>>> True + 1
2
>>> False + 1
1
>>> bool(0)   
False
>>> bool(1)
True

所以，True代表1，False代表0。

在python中所有的数据类型都可以转成布尔值。
布尔值为False的有:

• 整数值0、浮点数值0.0等、空字符串都为假""

• None为假

• 空数据对象都是假，比如[]、{}、()等

其他情况一律为True。

针对布尔值的变量名一般采用is开头

is_ok
is_delete

8. 元组:tuple

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

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

创建元组: 用小括号中添加元素，并使用逗号隔开。

可以用多种方式构建元组：

• 使用一对圆括号来表示空元组: ()
• 使用一个后缀的逗号来表示单元组: a, 或 (a,)
• 使用以逗号分隔的多个项: a, b, c or (a, b, c)
• 使用内置的 tuple(): tuple() 或 tuple(iterable)

示例:

>>> tuple1 = (1, 2, 3, 4, 5, 6, 7, 8, 9)      
>>> type(tuple1)
<class 'tuple'>

元组取值和列表一样，也是用下标(索引)，并且下标的值也是从0开始。
例如依然取5这个值，它的下标为4
>>> tuple1[4]
5
//元组和列表最大区别为列表可以修改，元组不可以修改，如:
//修改列表:
>>> list1
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> 
>>> list1[0]
1
>>> list1[0] = "A"
>>> list1[0]
'A'
>>> list1
['A', 2, 3, 4, 5, 6, 7, 8, 9]
//修改元组:
>>> tuple1
(1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> tuple1[0]
1
>>> tuple1[0]="AA"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment  //报错，元组不支持修改

9. 集合:set

集合也是容器，其内元素都是无序、唯一、不可变的。它常用来做成员测试、移除重复数据、数据计算(比如交集、并集、差集)。

可以使用大括号 { } 或者 set() 函数创建集合,元素与元素之间逗号隔开，创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

示例:

>>> x = {1, 2, 3, 4}
>>> type(x)
<class 'set'>
>>> y = {1, 1, 2, 2, 3, 3, 4, 4}
>>> y 				//去重功能
{1, 2, 3, 4}
>>> print(y)
{1, 2, 3, 4}

集合的三个特点：

1. 每个元素必须是不可变类型
2. 集合内没有重复的元素
3. 集合内元素无序

由于集合是通过hash值来存储的，没有位置索引。所以没法对集合进行单元素的检索，只能对集合进行修改操作，或迭代、遍历。

10. 用户交互

10.1 什么是用户交互

用户通过人机交互界面与系统交流，并进行操作，简单的区分为“输入”（Input）与“输出”（Output）两种。输入指的是由人来进行机械或设备的操作，输出指的是由机械或设备发出来的通知。

input() 函数接受一个标准输入数据，返回为 string 类型.使用input()可以进行用户交互

示例:

>>> num = input("please input a num:")
please input a num:123
>>> type(num)
<class 'str'>
>>> str1 = input("please input a string:")   
please input a string:Hello
>>> type(str1)
<class 'str'>

//不管输入的是什么，python 里input()接受后都是字符串类型。

11. 格式化输出

格式化输出即按照一定的格式输出。

>>> print("Hi, %s." % name)
Hi, Hans.

>>> print("Hello, %s. Welcome to %s" %("Hans", "BJ")) 
Hello, Hans. Welcome to BJ

其中%s为占位符。

print()常用参数:

• sep -- 用来间隔多个对象，默认值是一个空格。
• end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。

示例:

#sep
>>> print("www","pymysql","com")
www pymysql com
>>> print("www","pymysql","com", sep='.')
www.pymysql.com
#end. end默认是换行符，所以每次打印一次就会换行
>>> print("www.pymysql.com")             
www.pymysql.com
>>>

>>> print("www.pymysql.com",end='') #把默认换行换成空了，所以不自动换行了。
www.pymysql.com>>>   
>>> print("www.pymysql.com",end='#') ##把默认换行换成井号'#''
www.pymysql.com#>>> 
>>> 

练习:

1. 接受用户输入，打印指定格式
>>> name = input("Your name:") 
Your name:Hans
>>> age = input("Your age:")
Your age:18
>>> print("My name is %s, my age is %s"  %(name, age))
My name is Hans, my age is 18

2.用户输入姓名，年龄，性别，工作，爱好，然后安格式打印
cat person.py
name = input("name:")
age = input("age:")
gender = input("gender:")
job = input("job:")
hobby = input("hobby:")

print(
    """
    %s\tinfo to %s\t%s
    Name    : %s
    Age     : %s
    Sex     : %s
    Job     : %s
    Hobby   : %s
    %s\tend\t%s
    """ % ('_'* 10, name, '_'* 10,name, age, gender, job, hobby,'_'* 10,'_'* 10,)

)


python person.py
name:Hans
age:18
gender:male
job:student
hobby:study

    __________	info to hans	__________
    Name    : Hans
    Age     : 18
    Sex     : male
    Job     : student
    Hobby   : study
    __________	end	__________

12. 运算符

12.1 算术运算符

示例:

>>> 1 + 1
2
>>> 2 - 1
1
>>> 2 * 4
8
>>> 4 / 2
2.0
>>> 10 % 3
1
>>> 9 // 2
4

12.2 关系运算符

示例:

>>> "a" == "b"
False
>>> "a" != "b" 
True
>>> 3 > 4
False
>>> 3 < 4
True
>>> 3 >= 4
False
>>> 3 <= 4
True

12.3 赋值运算符

=赋值。

a = 20

12.4 增量赋值运算符

示例:

>>> a = 2
>>> a += 1
>>> a
3
>>> a -= 1
>>> a
2
>>> a *= 2
>>> a
4
>>> a /= 2
>>> a
2.0
>>> a = 10
>>> a %= 3
>>> a
1

>>> a = 2
>>> a **= 3
>>> a
8

>>> a = 9
>>> a //= 2
>>> a
4

13.5 链式赋值

链式赋值: 同时对几个变量进行赋值

示例:

a = 3
b = 3
c = 3
可以写成
a = b = c = 3

>>> a = b = c = 3
>>> a
3
>>> b
3
>>> c
3

13.6 交叉赋值

即交换两个变量的数值.

x = 10 
y = 20
如何把x 和y 的值交换即：x = 20, y = 10
方法1：利用第三个变量
>>> x = 10
>>> y = 20
>>> m = x
>>> x = y
>>> y = m
>>> x
20
>>> y
10

方法2：交叉赋值
>>> x = 10
>>> y = 20
>>> x, y = y, x
>>> x
20
>>> y
10

13.7 解压赋值

任何的序列 (或者是可迭代对象) 可以通过一个简单的赋值语句解压并赋值给多个变量。唯一的前提就是变量的数量必须跟序列元素的数量是一样的。

>>> number_list = [1, 2, 3, 4]
>>> num1, num2, num3, num4 = number_list
>>> num1
1
>>> num2
2
>>> num3
3
>>> num4
4

//少一个不行
>>> n1, n2, n3 = number_list            
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 3)
//多一个也不行
>>> n1, n2, n3, n4, n5 = number_list
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 5, got 4)
// 如果只想要第一个和最后一个，如何突破上面的限制：
//可以使用星号(*)
>>> number_list = [1, 2, 3, 4]
>>> n1, *a, n2 = number_list
>>> n1
1
>>> n2
4
>>> a  //把中间的都赋值给a
[2, 3]
//如果中间的数据不想要：
>>> nu1, *_, nu2 = number_list
>>> nu1
1
>>> n2
4

//可以接受多余的元素 组织成列表赋值给后面的变量名
//下划线单独作为变量名 通常表达的意思指向的值没有啥用

13. 逻辑运算符:与或非

示例：

1. and
>>> 1 and 2
2
>>> 0 and 2
0
>>> 3 and 1
1
>>> -1 and -2
-2

2. or

>>> 1 or 3
1
>>> 2 or 3 
2
>>> 2 or 0
2
>>> 0 or 0
0
>>> 0 or  1
1

3. not
>>> not True
False
>>> not False
True

逻辑运算符也是有优先级的:

not > and > or

不过编写程序时应该人为的规定好优先级，使用圆括号().

更多文章请关注《万象专栏》