Python——入门级(变量数据类型)

Python变量类型

变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。
基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。
因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。

---

Python标准数据类型

Python数字

数字数据类型用于存储数值。

Python支持四种不同的数字类型：

• int（有符号整型）
• long（长整型[也可以代表八进制和十六进制]）
• float（浮点型）
• complex（复数）

实例

int	long	float	complex
10	51923658L	0.0	3.14j
100	-0x19323L	15.20	45.j
-786	0122L	-21.9	9.322e-36j
080	0xDEFABCECBDAECBFBAEL	32.3e+18	.876j
-0490	535633629843L	-90.	-.6545+0J
-0x260	-052318172735L	-32.54e100	3e+26J
0x69	-4721885298529L	70.2E-12	4.53e-7j

语法

• 创建

var1=1
var2=10

• 删除

del var
del var_a, var_b

Python字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符。
一般记为 :

s="a1a2···an"(n>=0)

字符串列表有两种顺序

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

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

  
  
  index.png

截取字符串

使用[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。

>>> s = 'abcdef'
>>> s[1:5]
'bcde'

截取与索引.png

字符串连接与重复

加号（+）是字符串连接运算符，星号（*）是重复操作。

>>> str = 'Hello World!'
>>> print str           # 输出完整字符串
Hello World!

>>> print str[0]        # 输出字符串中的第一个字符
H

>>> print str[2:5]      # 输出字符串中第三个至第五个之间的字符串
llo

>>> print str[2:]       # 输出从第三个字符开始的字符串
llo World!

>>> print str * 2       # 输出字符串两次
Hello World!Hello World!

>>> print str + "TEST"  # 输出连接的字符串
Hello World!TEST

Python列表

列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
列表用 [ ] 标识，是 python 最通用的复合数据类型。

列表截取.png

列表迭代输出、连接与重复

>>> list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
>>> tinylist = [123, 'john']
 
>>> for content in list :
>>> print(content)
runoob
786
2.23
john
70.2

>>> for index in range(len(list)):
>>> print("index = ", index, ", number in list = ", list[index])
index =  0 , number in list =  runoob
index =  1 , number in list =  786
index =  2 , number in list =  2.23
index =  3 , number in list =  john
index =  4 , number in list =  70.2

>>> print list               # 输出完整列表
['runoob', 786, 2.23, 'john', 70.2]

>>> print list[0]            # 输出列表的第一个元素
runoob

>>> print list[1:3]          # 输出第二个至第三个元素 
[786, 2.23]

>>> print list[2:]           # 输出从第三个开始至列表末尾的所有元素
[2.23, 'john', 70.2]

>>> print tinylist * 2       # 输出列表两次
[123, 'john', 123, 'john']

>>> print list + tinylist    # 打印组合的列表
['runoob', 786, 2.23, 'john', 70.2, 123, 'john']

List 添加

列表是一系列有序的数列，有一系列自带的功能， 例如：

a = [1,2,3,4,1,1,-1]
a.append(0)  # 在a的最后面追加一个0
print(a)
# [1, 2, 3, 4, 1, 1, -1, 0]

在指定的地方添加项：

a = [1,2,3,4,1,1,-1]
a.insert(1,0) # 在位置1处添加0
print(a)
# [1, 0, 2, 3, 4, 1, 1, -1]

List 移除

删除项：

a = [1,2,3,4,1,1,-1]
a.remove(2) # 删除列表中第一个出现的值为2的项
print(a)
# [1, 3, 4, 1, 1, -1]

List 索引

显示特定位：

a = [1,2,3,4,1,1,-1]
print(a[0])  # 显示列表a的第0位的值
# 1

print(a[-1]) # 显示列表a的最末位的值
# -1

print(a[0:3]) # 显示列表a的从第0位 到 第2位(第3位之前) 的所有项的值
# [1, 2, 3]

print(a[5:])  # 显示列表a的第5位及以后的所有项的值
# [1, -1]

print(a[-3:]) # 显示列表a的倒数第3位及以后的所有项的值
# [1, 1, -1]

打印列表中的某个值的索引(index):

a = [1,2,3,4,1,1,-1]
print(a.index(2)) # 显示列表a中第一次出现的值为2的项的索引
# 1

统计列表中某值出现的次数：

a = [4,1,2,3,4,1,1,-1]
print(a.count(-1))
# 1

List 排序

对列表的项排序：

a = [4,1,2,3,4,1,1,-1]
a.sort() # 默认从小到大排序
print(a)
# [-1, 1, 1, 1, 2, 3, 4, 4]

a.sort(reverse=True) # 从大到小排序
print(a)
# [4, 4, 3, 2, 1, 1, 1, -1]

Python多维列表

• 创建多维列表

一个一维的List是线性的List，多维List是一个平面的List：

a = [1,2,3,4,5] # 一行五列

multi_dim_a = [[1,2,3],
               [2,3,4],
               [3,4,5]] # 三行三列

• 索引

print(a[1])
# 2

print(multi_dim_a[0][1])
# 2

用行数和列数来定位list中的值。这里用的是二维的列表，但可以有更多的维度。

矩阵的话是，可以引入numpy

Python元组(相当于只读列表)

元组是另一个数据类型，类似于List（列表）。
元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

>>> tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
>>> tinytuple = (123, 'john')
 
>>> print tuple               # 输出完整元组
('runoob', 786, 2.23, 'john', 70.2)

>>> print tuple[0]            # 输出元组的第一个元素
runoob

>>> print tuple[1:3]          # 输出第二个至第三个的元素 
(786, 2.23)

>>> print tuple[2:]           # 输出从第三个开始至列表末尾的所有元素
(2.23, 'john', 70.2)

>>> print tinytuple * 2       # 输出元组两次
(123, 'john', 123, 'john')

>>> print tuple + tinytuple   # 打印组合的元组
('runoob', 786, 2.23, 'john', 70.2, 123, 'john')

以下是元组无效的，因为元组是不允许更新的。而列表是允许更新的：

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tuple[2] = 1000    # 元组中是非法应用
list[2] = 1000     # 列表中是合法应用

Python字典

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
例1

>>> dict = {}
>>> dict['one'] = "This is one"
>>> dict[2] = "This is two"
>>> tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
 
>>> print dict['one']          # 输出键为'one' 的值
This is one

>>> print dict[2]              # 输出键为 2 的值
This is two

>>> print tinydict             # 输出完整的字典
{'dept': 'sales', 'code': 6734, 'name': 'john'}

>>> print tinydict.keys()      # 输出所有键
['dept', 'code', 'name']

>>> print tinydict.values()    # 输出所有值
['sales', 6734, 'john']

例2

a_list = [1,2,3,4,5,6,7,8]

d1 = {'apple':1, 'pear':2, 'orange':3}
d2 = {1:'a', 2:'b', 3:'c'}
d3 = {1:'a', 'b':2, 'c':3}

print(d1['apple'])  # 1
print(a_list[0])    # 1

del d1['pear']
print(d1)   # {'orange': 3, 'apple': 1}

d1['b'] = 20
print(d1)   # {'orange': 3, 'b': 20, 'pear': 2, 'apple': 1}

字典存储类型
以上的例子可以对列表中的元素进行增减。在打印出整个列表时，可以发现各个元素并没有按规律打印出来，进一步验证了字典是一个无序的容器。

def func():
    return 0

d4 = {'apple':[1,2,3], 'pear':{1:3, 3:'a'}, 'orange':func}#字典嵌套字典
print(d4['pear'][3])    # a

字典还可以以更多样的形式出现，例如字典的元素可以是一个List，或者再是一个列表，再或者是一个function。索引需要的项目时，只需要正确指定对应的key就可以了。

---

Python赋值

变量赋值

Python 中的变量赋值不需要类型声明。
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
等号（=）用来给变量赋值。
等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串

多个变量赋值

Python允许你同时为多个变量赋值。创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。例如：

a = b = c = 1

您也可以为多个对象指定多个变量。例如：

a, b, c = 1, 2, "john"

Python数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

函数	描述	实例
int(x[,base])	将x转换成整数,base为输入的进制	int('12',16) 输出18
long(x[,base])	将x转换成长整数	long(1) 输出1L
float(x)	将x转换成浮点数	float(1) 输出1.0
complex(real[,imag])	创建一个复数	complex(1, 2) 输出(1+2j)
str(x)	将x转换成字符串	str(s)
repr(x)	将对象 x 转换为表达式字符串	`
eval(x)	用来计算在字符串中的有效Python表达式,并返回一个对象	`
tuple(x)	将序列x 转换为一个元组	`
list(x)	将序列x转换为一个列表	`
set(x)	将序列x 转换为一个可变集合	`
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组。	`
frozenset(x)	转换为不可变集合	`
chr(x)	将一个整数转换为一个字符	`
unichr(x)	将一个整数转换为Unicode字符	`
set(x)	将序列x 转换为一个可变集合	`
ord(x)	将一个字符转换为它的整数值	`
hex(x)	将一个整数转换为一个十六进制字符串	`
oct(x)	将一个整数转换为一个八进制字符串	`

>>> int(3.6)
3
>>> int('0xa',16)   # 如果是带参数base的话，0xa要以字符串的形式进行输入，0xa为 16进制
10

>>>long()
0L
>>> long('123')
123L

>>> float(-123.6)
-123.6
>>> float('123')     # 字符串
123.0

>>> complex("1")  # 当做字符串处理
(1 + 0j) 
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)

>>>s = 'RUNOOB'
>>> str(s)
'RUNOOB'
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> str(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"

>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"

>>>x = 7
>>> eval( '3 * x' )
21

>>>dict()                        # 创建空字典
{}
>>> dict(a='a', b='b', t='t')     # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1} 
>>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}

>>>a = frozenset(range(10))     # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob') 
>>> b
frozenset(['b', 'r', 'u', 'o', 'n'])   # 创建不可变集合

>>>ord('a')
97