标签：负数   his   内存地址   影响   无限循环   aaa   oat   关于   sort   

1、python数据类型：

str（字符串）

number（数字）整数 int，浮点数 float，复数 complex

bool（布尔值）

none（空值）

list（列表）

tuple（元组）

dict（字典）

set（集合）

2、数据类型之字符串（string）

2.1、什么是字符串？

若干个字符的集合就是一个字符串（String）。python中的字符串必须由单引号‘ ‘，或双引号" "，或者三引号‘‘‘ ‘‘‘包围，具体格式为：

‘string‘
"string"
‘‘‘string‘‘‘
‘‘‘It‘s "python",I have "A" and "B"。‘‘‘

2.2、字符串创建

msg = "你真是一个小天才！！！"

2.3、获取字符串中的字符

可以使用索引去截取字符串中的字符，索引支持负数。

python的字串列表有2种取值顺序:

　　从左到右索引默认0开始的，最大范围是字符串长度少1；

　　从右到左索引默认-1开始的，最大范围是字符串开头；

hello
#该字符串下标可为：
#从左到右：(0,1,2,3,4)
#从右到左：(-5,-4,-3,-2,-1)

如果你要实现从字符串中获取一段子字符串的话，可以使用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。

[头下标:尾下标] 此方法获取字符串下标，取值为半包含，获取的子字符串包含头下标的字符，但不包含尾下标的字符。

a = "l love python"
print(a[:]) #表示从头取到尾
print(a[0-5])   #表示获取字符串中下标为0-4的字符

python 列表截取可以接收第三个参数，参数作用是截取的步长。

str = "abababababa"
print(str[2:10:2])    #截取字符串下标为2到10的字符，步幅为2

输出结果：aaaa

2.4、字符串连接

say = "老师说:"
msg = "你真是一个小天才!!!"
print(say+msg)

2.5、字符串重复

msg = "你真是一个小天才!!!"
print(msg+msg+msg)  或
print(msg*3) 

2.6、使用方法修改字符串

#Author: Caesars
str = "we love python VERY MUCH"
print(str.title())  #将字符串修改为首字母大写，其余小写格式
print(str.upper())  #将字符串修改为全部大写格式
print(str.lower())  #将字符串修改为全部小写格式

输出结果：

We Love Python Very Much
WE LOVE PYTHON VERY MUCH
we love python very much

注：str.title()中，name后面的 . 是python中对变量str追加执行的方法。

2.7、格式化字符串

常用占用符

%s	格式化字符串
%d	格式化整数
%f	格式化浮点数字，可指定小数后的精确度。

例：

sex = "男"
age = 18
f = 1.16
print("我性别%s,今年%d岁了,体重又增加了%.01f公斤。" %(sex, age, f))

运行结果为：我性别男,今年18岁了,体重又增加了1.2公斤。

2.8、常用转义字符串

①\\  

print("this is a \\beautiful/")

输出结果为：this is a \beautiful/

②\‘

③\"

print("你真是一个\"小天才\"！！！")    #字符串中使用引号需要\进行转义

输出结为：你真是一个"小天才"！！！

④\n

print("python \nC")

输出结果为：

python
C

⑤\t

r 如果字符串中很多字符都需要转义，可以使用r保持原有格式

print("今天\t是个好日子！！！")
print(r"今天\t是个好日子！！！")

输出结果为:

今天    是个好日子！！！
今天\t是个好日子！！！

2.9、删除空白

name = "\tpython\t"
print(name)
print(name.rstrip())    #截掉字符串末尾的指定字符（默认是空格）
print(name.lstrip())    #截掉字符串首部的指定字符（默认是空格）
print(name.strip())     #截掉字符串头尾的指定字符（默认是空格）

输出结果为：

　　python 　　　（字符串前后均有空格）
　　python　　　　(仅字符串前边有空格)
python　　　　　　(仅字符串后边有空格)
python　　　　　　(字符串前后均无空格)

3、数据类型之整型（int）

3.1、python中的整型介绍

整数就是没有小数部分的数字，python中的整数包括正整数、0 和负整数。

有些强类型的编程语言会提供多种整数类型，每种类型的长度都不同，能容纳的整数的大小也不同，开发者要根据实际数字的大小选用不同的类型。例如C语言提供了 short、int、long、long long 四种类型的整数，它们的长度依次递增，初学者在选择整数类型时往往比较迷惑，有时候还会导致数值溢出。

而 Python 则不同，它的整数不分类型，或者说它只有一种类型的整数。Python 整数的取值范围是无限的，不管多大或者多小的数字，Python 都能轻松处理。

当所用数值超过计算机自身的计算能力时，Python 会自动转用高精度计算（大数计算）。

3.2、整型的创建与使用操作

n = 66  #定义一个整型变量n，且将78赋值给变量n
print(n)
print(type(n))  #打印出变量n的类型

输出结果为：

66

可以清楚看到，变量的数据类型为int。

#给num1赋值一个很大的整数
num1 = 9999999999999999999999999
print(num1)
print(type(num1))

#给num2赋值一个很小的整数
num2 = -9999999999999999999999999
print(num2)
print(type(num2))

运行结果为：

9999999999999999999999999

-9999999999999999999999999

num1是一个极大的数字，num2 是一个很小的数字，Python 都能正确输出，不会发生溢出，这说明 Python 对整数的处理能力非常强大。

不管对于多大或者多小的整数，Python 只用一种类型存储，就是 int。

关于python2.x

python 3.x 只用 int 一种类型存储整数，但是 Python 2.x 会使用 long 类型来存储较大的整数。以上代码在 Python 2.x 下的运行结果为：

9999999999999999999999999

-9999999999999999999999999

但是不管哪个版本的 Python，都能轻松处理极大和极小的数字，而且程序员也不用操心底层到底使用了 int 还是 long 类型。

3.3、整数的不同进制

在 Python 中，可以使用多种进制来表示整数：

（1）十进制形式

我们平时常见的整数就是十进制形式，它由 0~9 共十个数字排列组合而成。

注意，使用十进制形式的整数不能以 0 作为开头，除非这个数值本身就是 0。

（2）二进制形式

由 0 和 1 两个数字组成，书写时以0b或0B开头。例如，101 对应十进制数是 5。

（3）八进制形式

八进制整数由 0~7 共八个数字组成，以0o或0O开头。注意，第一个符号是数字 0，第二个符号是大写或小写的字母 O。

在 Python 2.x 中，八进制数字还可以直接以0（数字零）开头。

（4）十六进制形式

由 0~9 十个数字以及 A~F（或 a~f）六个字母组成，书写时以0x或0X开头。

不同进制整数在python中的使用：

#Author: Caesars
hex1 = 0x36
hex2 = 0x1AE
print("hex1value:",hex1)
print("hex2value:",hex2)

bin1 = 0b110
bin2 = 0B001
print("bin1value:",bin1)
print("bin2value:",bin2)

oct1 = 0o56
oct2 = 0O77
print("oct1value:",oct1)
print("oct2value:",oct2)

运行结果为：

hex1value: 54
hex2value: 430
bin1value: 6
bin2value: 1
oct1value: 46
oct2value: 63

（输出结果均为十进制表示）

3.4、数字分隔符

为了提高数字的的可读性，Python 3.x 允许使用下划线_作为数字（包括整数和小数）的分隔符。通常每隔三个数字添加一个下划线，类似于英文数字中的逗号。下划线不会影响数字本身的值。

示例：使用下划线书写数字

tel = 138_9438_4438
wechat = 9999_9999
print("联系电话：",tel)
print("微信号：",wechat)

输出结果：

联系电话： 13894384438
微信号： 99999999

4、数据类型之浮点型（float）

在编程语言中，小数通常以浮点数的形式存储。浮点数和定点数是相对的：小数在存储过程中如果小数点发生移动，就称为浮点数；如果小数点不动，就称为定点数。

python中的小数有两种书写形式：

（1）十进制形式

这种就是我们平时看到的小数形式，例如 666.0、66.6、0.666。

书写小数时必须包含一个小数点，否则会被 Python 当作整数处理。

（2）指数形式

aEn 或 aen

a 为尾数部分，是一个十进制数；n 为指数部分，是一个十进制整数；E或e是固定的字符，用于分割尾数部分和指数部分。整个表达式等价于 a×10ⁿ。

指数形式的小数举例：

• 2.1E5 = 2.1×10⁵，其中 2.1 是尾数，5 是指数。
• 3.7E-2 = 3.7×10^-2，其中 3.7 是尾数，-2 是指数。
• 0.5E7 = 0.5×10⁷，其中 0.5 是尾数，7 是指数。

注意，只要写成指数形式就是小数，即使它的最终值看起来像一个整数。例如 14E3 等价于 14000，但 14E3 是一个小数。

Python 只有一种小数类型，就是 float。C语言有两种小数类型，分别是 float 和 double：float 能容纳的小数范围比较小，double 能容纳的小数范围比较大。

实例：小数在python中的使用

f1 = 9.99999999999999999999999999999999999
print(f1)
print(type(f1))

f2 = 0.00000000000000000000000000000000009
print(f2)
print(type(f2))

f3 = 5e6
print(f3)
print(type(f3))

f4 = 6.6 * 10
print(f4)
print(type(f4))

输出结果：

10.0

9e-35

5000000.0

66.0

从运行结果可以看出，python 能容纳极小和极大的浮点数。print 在输出浮点数时，会根据浮点数的长度和大小适当的舍去一部分数字，或者采用科学计数法。

f4 的值是 66，但是它依然是小数类型，而不是整数类型。

但是f1的值是：9.99999999999999999999999999999999999，输出结果是：是10.0。print输出的却不精准，这是因为小数在内存中是以二进制形式存储的，小数点后面的部分在转换成二进制时很有可能是一串无限循环的数字，无论如何都不能精确表示，所以小数的计算结果一般都是不精确的。

5、数据类型之复数类型

复数（Complex）是 python 的内置类型，直接书写即可。换句话说，python 语言本身就支持复数，而不依赖于标准库或者第三方库。

复数由实部（real）和虚部（imag）构成，在 Python 中，复数的虚部以j或者J作为后缀，具体格式为：

a + bj

a 表示实部，b 表示虚部。

5.1、在python中复数的使用

#Author: Caesars
c1 = 6 + 0.6j
print("c1value:",c1)
print("c1type:",type(c1))

c2 = 8 - 0.8j
print("c2value:",c2)
print("c2type:",type(c2))

运行结果为：

c1value: (6+0.6j)
c1type:
c2value: (8-0.8j)
c2type:
c1+c2= (14-0.20000000000000007j)
c1*c2= (48.48-8.881784197001252e-16j)

可以发现，复数在 python 内部的类型是 complex，Python 默认支持对复数的简单计算。

6、数据类型之列表（list）

6.1、什么是列表？

列表是python中最基本的数据结构，它是一个有序序列，序列中的每个元素都分配一个数字(位置、索引)。

列表用 []标识，是 python 最通用的复合数据类型。

列表创建：

nums1 = [1, 2, 3, 4]

nums2 = list("abcdef")

6.2、访问列表中的数据

列表是有序序列，存在下表index。[a:b]，是半封闭，含左不含右。下标从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

#Author: Caesars
nums = list("abcdef")
print(nums)
print(nums[0:3])　　
print(nums[-4:-2])
l = nums[0]
print(l)

输出结果为：

[‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘]
[‘a‘, ‘b‘, ‘c‘]
[‘c‘, ‘d‘]
a

6.3、列表常用操作

6.3.1、列表数据修改

ll = [1, 2, 3, 4]
print(ll)
l1 = ll[3]
print(l1)
print(ll[3])
ll[3] = "ggg"
print(ll[3])

输出结果为：

[1, 2, 3, 4]
4
4
ggg

6.3.2、列表数据删除

ll = [1, 2, 3, 4]
del ll[3]
print(ll)

输出结果为：

[1, 2, 3]

6.3.3、列表数据组合

l1 = [1, 2, 3, 4]
l2 = list("a,b,c,d")
print(l1+l2)

输出结果为：

[1, 2, 3, 4, ‘a‘, ‘,‘, ‘b‘, ‘,‘, ‘c‘, ‘,‘, ‘d‘]

6.3.4、列表数据重复

l1 = [1, 2, 3, 4]
print(l1*3)

输出结果为：

[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

6.4、列表常用方法

复制（“深copy”与“浅copy”）

（1）浅“copy”，实质上是对第一个列表元素的引用。

#Author: Caesars
import copy

l1 = ["name",["zhang","lisi"]]
print(l1)
#方法1
l2 = l1.copy()
l3 = l1.copy()
# 方法2
# l2 = copy.copy(l1)
# l3 = copy.copy(l1)
# 方法3
# l2 = l1[:]
# l3 = l1[:]
# 方法4
# l2 = list(l1)
# l3 = list(l1)

l2[0] = "zhangsan"
l3[0] = "lisi"

l2[1][1] = 50

print(l2)
print(l3)

输出结果为：

[‘name‘, [‘zhang‘, ‘lisi‘]]
[‘zhangsan‘, [‘zhang‘, 50]]
[‘lisi‘, [‘zhang‘, 50]]

对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。

（2）深“copy”

#Author: Caesars
import copy
l1 = ["name",["a",100]]
print(l1)
l2 = copy.deepcopy(l1)
l3 = copy.deepcopy(l1)
l2[0] = "zhangsan"
l3[0] = "lisi"

l2[1][1] = 50

print(l2)
print(l3)

输出结果为：

[‘name‘, [‘a‘, 100]]
[‘zhangsan‘, [‘a‘, 50]]
[‘lisi‘, [‘a‘, 100]]

深拷贝不仅仅拷贝最外层容器，还会拷贝容器中的元素。

#append 追加

l1 = [1,2,3,4]
print(l1)
l1.append(5)
print(l1)

输出结果为：

[1, 2, 3, 4]
[1, 2, 3, 4, 5]

#extend 扩展

l1 = [1,2,3,4]
l2 = [6,7,8]
l1.extend(l2)
print(l1)

输出结果为：

[1, 2, 3, 4, 6, 7, 8]

#insert 插入

l1 = [1,2,3,4]
l1.insert(0,0)
print(l1)

输出结果为：

[0, 1, 2, 3, 4]

#pop 弹出

l1 = [1,2,3,4]
l1.pop()
print(l1)

输出结果为：

[1, 2, 3]

#remove() 函数用于移除列表中某个值的第一个匹配项。

l1 = [1,2,3,4]
l1.remove(1)
print(l1)

输出结果为：

[2, 3, 4]

#clear 清空

l1 = [1,2,3,4]
l1.clear()
print(l1)

输出结果为：

[]

#index 查询索引

l1 = [1,2,3,4]
print(l1.index(2))

输出结果为：

1

#reverse 反转

l1 = [1,2,3,4]
l1.reverse()
print(l1)

输出结果为：

[4, 3, 2, 1]

#sort 排序

l1 = [20,15,6,89,55]
l1.sort()
print(l1)

输出结果为：

[6, 15, 20, 55, 89]

Python数据类型介绍（一）

标签：负数   his   内存地址   影响   无限循环   aaa   oat   关于   sort   

原文地址：https://www.cnblogs.com/Caesars/p/12722571.html