pyhton3语法基础随记——数据类型

python数据类型

python中变量不需要声明，变量被赋值之后即被创建

变量就是变量，它没有类型，我们所说的类型是它存储在内存中的对象类型

变量创建

多个变量同时创建！

a,b,c=15,'www',[156,'dfg',12.65]

a
Out[10]: 15

b
Out[11]: 'www'

c
Out[12]: [156, 'dfg', 12.65]

删除变量

del a,b,c

八大标准数据类型

Python3 中有八大标准的数据类型：

• 常量
• 布尔类型
• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

八大标准数据类型解析

-常量

变量是变化的量，常量则是不变的量。

python中没有使用语法强制定义常量，也就是说，python中定义常量本质上就是变量。

如果非要定义常量，变量名必须全大写,以便区别。

如果是常量，那就没必要更改，所以python就只制定了一个规范，而没指定常量的语法，
因此常量也是可以修改的，但不建议。python中也有一些内置常量。
可以使用模块与类来实现真正的常量
在c语言中有专门的常量定义语法，const int a = 100;，一旦定义age为常量，更改age即会报错 。

WWW='ABC'

WWW+='DEF'

WWW    #常量可更改 一般常量是不可更改的 不建议修改
Out[3]: 'ABCDEF'

更多python常量解析可参考 python 常量（最全常量解析） 这个大佬写的可好了呜呜呜

- bool（布尔类型）

python 中布尔值使用常量True 和 False来表示；注意大小写

比较运算符< > == 等返回的类型就是bool类型；

布尔类型通常在 if 和 while 语句中应用；

布尔运算 and or not ；
注意布尔运算的优先级低于表达式， not a == b 相当于 not (a == b), 若 a == not b 就会有语法错误

详见 python 中的bool类型

- Number（数字）

Python3 支持 int、float、complex（复数）三种类型。

数字常用于计算、比较

数字属于不可变数据，不可修改

整型(int)

• 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。

浮点型(float)

• 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

复数( (complex))

• 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

创建与删除

直接赋值创建变量法

a,b,c=5,5.5,3+5j #整数、浮点数、复数

a
Out[27]: 5

b
Out[28]: 5.5

c
Out[29]: (3+5j)

删除变量

del a,b,c

有序序列 {说明}

常见的有序序列是 字符串、列表、元组。可以按照索引取数、切片、倒叙，
也可以认为有序序列就是有索引可以进行各种操作

有序序列可以进行取数、切片、倒序 。要进行这些操作就必须确定有序序列的
首索引、尾索引、方向步伐
{注意：尾索引不包含、步伐为正数则方向 从前往后 遍历，步伐为负数则方向 从后往前 遍历 默认为1}

#定义 字符串 列表 元组
a="abcde"
b=[1,2.0,"aaa",'bbb',"ccc"]
c=("a","b",2,3,4)

顺序索引	0	1	2	3	4
字符串	a	b	c	d	e
列表	1	2.0	“aaa”	‘bbb’	“ccc”
元组	“a”	“b”	2	3	4
逆序索引	-5	-4	-3	-2	-1

- String（字符串）

Python中的字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

字符串属于不可变数据，不可修改

'I\'m Mike'
Out[37]: "I'm Mike"

"I'm Mike"
Out[38]: "I'm Mike"

字符串属于有序序列、可取数，切片、倒序
有序序列切片从后往前是从-1开始，从前往后是从0开始
加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数

hi="I'm Mike"
#取数
hi[0]
Out[40]: 'I'
#正向切片
hi[0:5:1]
Out[41]: "I'm M"
#逆向切片
hi[::-1]
Out[42]: "ekiM m'I"
#以下两个输出一致，首索引与尾索引表示意义一样，-2表示逆向遍历间隔跳跃两次
hi[-2:-7:-2]
Out[43]: 'kMm'

hi[6:1:-2]
Out[44]: 'kMm'

#字符串拼接
"aaa"+"bbb"
Out[45]: 'aaabbb'
#字符串重复
"abc"*2
Out[46]: 'abcabc'

- List（列表）

列表 用[ ]存放数据，可以是不同的数据类型数据
列表是有序序列，也可以 取数、切片、倒序，与字符串一致不在复述

字符串属于可变数据，可修改。

• 增
  • 列表.append（元素 ) 末尾添加1个元素
  • 列表.extend（ [ 多个元素 ] ) 末尾添加多个元素
  • 列表.insert( 位置，元素) 在列表某位置插入元素
• 删
  • 列表.pop(） 默认删除最后一个并返回删除的元素
  • 列表.pop(n) 删除第n个元素(从0或-1遍历)返回删除的元素
  • 列表.remove（元素） 删除指定元素并且没有返回值
  • del 列表某元素 删除指定列表某元素
  • 列表.clear() 清空列表内容
  • del(列表) 删除列表
• 改
  • 新元素 赋值（=） 给旧元素实现更改
• 查
  • 列表.index(某元素) 返回某元素的索引位置
• 反转
  • 列表.reverse（） 列表反转 与 [ : : -1] 结果一样
• 计数
  • 列表.count( 元素 ) 计数某元素返回数值
• 排序
  • 列表.sort() 把列表从小到大排序
  • 列表.sort(reverse=True) 把列表从大到小排序
    

#定义一个列表
a=[1,2,3,4]

#增
a.append(5)

a.append([5,6])

a
Out[3]: [1, 2, 3, 4, 5, [5, 6]]

a.extend([6,7])

a
Out[5]: [1, 2, 3, 4, 5, [5, 6], 6, 7]

a.insert(0,0)

a
Out[7]: [0, 1, 2, 3, 4, 5, [5, 6], 6, 7]
#删
a.pop()
Out[8]: 7

a.pop(-1)
Out[9]: 6

a.remove([5,6])

a
Out[11]: [0, 1, 2, 3, 4, 5]

del a[0]

a
Out[13]: [1, 2, 3, 4, 5]

a.clear()

a
Out[15]: []

del a

a=[1,2,3,4]
#改
a[0]=5

a
Out[19]: [5, 2, 3, 4]
#查
a.index(2)
Out[20]: 1
#翻转
a.reverse()

a
Out[22]: [4, 3, 2, 5]
#计数
a.count(4)
Out[23]: 1
#排序
a.sort()

a
Out[25]: [2, 3, 4, 5]

a.sort(reverse=True)

a
Out[27]: [5, 4, 3, 2]

列表的快速计算

也可用于元组

1. 求和 sum(列表)
2. 求最小 min(列表)
3. 求最大max(列表)
4. 求长度len(列表)

列表与列表之间可以进行拼接（+、*）（元组同理）

a=[1,2,3,4]

sum(a)
Out[2]: 10

min(a)
Out[3]: 1

max(a)
Out[4]: 4

a=[1,2,3,"abcd",'"']

a+a
Out[30]: [1, 2, 3, 'abcd', '"', 1, 2, 3, 'abcd', '"']

a*2
Out[31]: [1, 2, 3, 'abcd', '"', 1, 2, 3, 'abcd', '"']

- Tuple（元组）

元组 用（）存放数据，可以是不同的数据类型数据
元组是有序序列，可以 取数、切片、倒序，与字符串一致

元组属于不可变数据，不可修改。

a=(1,2,3,"abcd",'"')
#取数
a[4]
Out[8]: '"'

a[3]
Out[9]: 'abcd'
#切片
a[3][::-1]
Out[10]: 'dcba'

a[3][::2]
Out[11]: 'ac'

a[::]
Out[21]: (1, 2, 3, 'abcd', '"')

a[:3]
Out[22]: (1, 2, 3)

#倒序
a[::-1]
Out[20]: ('"', 'abcd', 3, 2, 1)

#修改报错
a[3]=3
Traceback (most recent call last):

  File "<ipython-input-12-21621c9e8b3a>", line 1, in <module>
    a[3]=3

TypeError: 'tuple' object does not support item assignment

- Set（集合）

集合 用 { } 存放数据，可以是不同的数据类型数据 ，它不会包含重复的值
集合是不是有序序列，没有索引一说

集合属于可变数据，可增删。

• 增

  • 集合.add（元素） 向集合中增加一个元素，元素不重复则添加并且集合会自动的从小到大排序
  • 集合.update(多个元素) 多个元素使用有序序列模式，可以是列表、集合、元组等

• 删

  • 集合.remove(元素) 删除指定的某元素
  • 集合.discard(元素) 删除指定的某元素
  • 集合.pop() 删除随机一个集合元素
  • 集合.clear() 清空集合
  • del 集合 删除集合

• 交集、并集、差集（与数学上的集合意义一致）

  • 交 集合间共有的元素
  • 并 集合所有元素集合
  • 差 集合相减的数集（看谁减谁）

#创建空集合时用set（），不用{ }否则会误认为时字典而不是列表了
a=set()

#集合会自动去除重复的值
a={1,1,1,1,1,1,2,2,2,3,3,3}

a
Out[51]: {1, 2, 3}

#增
a.add(0)

a
Out[110]: {0, 1, 2, 3}

a.update([1.5,2.5])

a
Out[112]: {0, 1, 1.5, 2, 2.5, 3}
#删
a.remove(0)

a.discard(1.5)

a
Out[116]: {1, 2, 2.5, 3}

a.pop()
Out[117]: 1

a.clear()

a
Out[119]: set()

del a

#定义两个集合
n={1,2,3,4,5,6}

m={4,5,6,7,8,9}

#求交集 &
n&m
Out[123]: {4, 5, 6}
#求并集 |
n|m
Out[124]: {1, 2, 3, 4, 5, 6, 7, 8, 9}
#求差集 -
n-m
Out[125]: {1, 2, 3}

m-n
Out[126]: {7, 8, 9}

- Dictionary（字典）

字典用 { 键：值，键：值, ~~} 存放数据，键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

字典是不是有序序列，没有索引一说 。但是从另一种意义上说键其实可以作为字典某一个值的索引

字典属于可变数据，可修改。

• 增
  • 增加键值对
• 删
  • 删除键值对
• 改
  • 修改键值对
• 查
  • 查询键值对

n [132]: dict1={"I":"我","am":"是","angle":"天使"}

#改
dict1["angle"]="女孩"

dict1["evil"]="男孩"

dict1
Out[135]: {'I': '我', 'am': '是', 'angle': '女孩', 'evil': '男孩'}
#查
dict1["I"]
Out[136]: '我'
#删
del dict1["evil"]

dict1
Out[138]: {'I': '我', 'am': '是', 'angle': '女孩'}
#清空
dict1.clear()

dict1
Out[140]: {}
#删除
del dict1

python数据类型查看与转换

查看数据类型

type(数据)函数 返回数据类型

a,b,c=1,'bbb',["ccc",54.2,'ddd']

type(a)
Out[23]: int

type(b)
Out[24]: str

type(c)
Out[25]: list

转换数据类型

详见菜鸟教程链接