python的基础数据类型

发表于 | 分类于 ，
字数统计: 3.1k 字 | 阅读时长 ≈ 13 分钟

本文主要记录了python的基础数据类型。运行环境：macOS 10.12.6

python的内存空间

(1)变量引用计数

输入以下代码：

1
a=123  b=123  c=123

查询a、b、c的id，结果为：

1
2
3
id(a)= 140639992833056
id(b)= 140639992833056
id(c)= 140639992833056

这说明python动态申请了一个空间，存储了123。然后变量同时指向了这个地址单元。此时引用计数为3。
在上述代码的基础上，添加代码b=789,查询id后的结果如下。

1
2
3
id(a)= 140639992833056
id(b)= 140639992864208
id(c)= 140639992833056

可以看出，此时b指向了另一个地址单元，而a和b依然指向原地址单元。相当于在C语言中，用malloc()开辟一个空间，然后将指针指向该空间。

这样做的好处在于节约内存的开销。

(2)del语句可以直接释放资源，变量名删除，引用计数减1

(3)变量内存自动管理回收，垃圾收集

如果将a和c都不指向123后，再新建一个变量c=123,此时c的id依旧为140639992833056，这样做的好处在于减少了malloc()和free()的反复性。

实际上，python中的引用计数，当其为0时，若内存不足/优化内存时，该内存会被释放。

python中使用中文

  • (1)需要使用中文时，在文件开头写入：#--coding:UTF-8--或者#coding=utf-8来指定编码。
  • (2)在python中，注释为#

简单函数

函数定义的格式如下。

1
2
3
4
5
def add(x,y):
    z=x+y
    return z
res = add(3,5)
print res

  • (1)def定义函数的关键字
  • (2)x和y为形参，不需要类型修饰
  • (3)函数定义行需要跟：
  • (4)函数体整体缩进(不缩进报错！)
  • (5)函数可以有返回值，若无返回值，返回None(会自动返回，也可以手动返回)

局部变量和全局变量

代码1：局部变量作用于覆盖全局变量

1
2
3
4
5
6
7
8
def p_num():
    num=5
    print num
num=10
p_num()
print num

#结果： 5 10

代码2：函数内定义了局部变量，则解释器不使用全局变量，如果局部变量的定义晚于被引用，则报错

1
2
3
4
5
6
7
8
9
def p_num():
    print num
    num=5   #若注释，则输出结果为10 10 10
    print num
num=10
p_num()
print num

#结果：报错！

代码3：函数内部可以直接访问全局变量

1
2
3
4
5
6
7
def p_num():
    print num
num=10
p_num()
print num

#结果：10 10

代码4：函数内修改全局变量，使用global关键字

1
2
3
4
5
6
7
8
9
10
def p_num():
    global num #声明num为全局变量
    print num
    num = 8
    print num
num=10
p_num()
print num

#结果：10 8 8

注：在实际开发中，尽量少使用全局变量！！

特殊变量

1
2
3
_xxx    from module import *无法导入
__xxx__ 系统定义的变量
__xxx   类的本地变量

表达式

算数表达式

1
2
3
4
5
6
7
8
9
10
+a      结果符号不变
-a      对结果符号取负
a+b     a加b
a-b     a减b
a**b    a的b次幂
a* b    a乘以b
a/b     a除以b，真正除，浮点数保留小数 
        (10.0/3=3.3333333333333335 , 10/3=3)
a//b    a除以b，向下取整
a%b     a对b取余数

逻辑表达式

1
2
3
4
5
not a       a的逻辑非
a and b     a和b逻辑与
a or b      a和b逻辑或
a is b      a和b时同一个对象
a is not b  a和b不是同一个对象

关系表达式

1
2
3
4
5
6
==  等于
!=  不等于（<>）
>   大于
<   小于
>=  大于等于
<=  小于等于

位运算

1
2
3
4
5
6
~a      按位取反
a << n  a左移n位
a >> n  a右移n位  
a & b   a和b按位与
a | b   a和b按位或
a ^ b   a和b按位异或

语句格式

语法格式

缩进表示关系，函数、分支、循环语句后面带“：”

分支语句

1
2
3
4
5
# if-else语句
if a>b:
    print("aaaa")
else:
    print("bbbb")
1
2
3
4
5
6
7
8
# if-elif-else语句
if a>b:
    print("a>b")
elif a==b:
    print("a==b")
else:
    print("a<b")
    print("hello world") #按缩进表示语句所属的层次

循环语句

(1)while语句：

1
2
while 判断条件：
    执行语句

示例：

1
2
3
4
5
var = 1
while var ==1:
    num = raw_input("Enter a number :   ")
    print  num
    print ("Goodbye!")

(2)for语句:for循环可以遍历任何序列的项目，如一个列表或者一个字符串

1
2
for iterating_var in sequence:
    执行语句

示例：

1
2
3
4
5
6
for letter in 'Python':
    print 'Current letter :', letter

fruits = ['banana','apple','mango']
for fruit in fruits:
    print 'Current fruit :', fruit

(3)for…else语句和while…else语句：for中的语句和普通的没有区别，else中的语句会在循环正常执行完（即for不是通过break跳出而中断）的情况下执行，while…else也一样。

1
2
3
4
5
6
7
8
9
10
count = 0
while count % 2 ==0:
    print count, " is oushu"
    count = count +1
else:
    print count, " is jishu"

#结果：
0  is oushu
1  is jishu

1
2
3
4
5
6
7
8
9
10
11
12
fruits = ['banana','apple','mango']
for fruit in fruits:
    print 'Current fruit :', fruit
    if fruit == 'apple':
        break
    else:
        print "ok"

#结果：
Current fruit : banana
ok
Current fruit : apple

break语句

break语句与C语言中一样，打破最小封闭for或者while循环。

continue语句

continue语句跳出本次循环，然后继续进行下一轮循环。只能用于while和for循环中。break跳出整个循环。

列表List

可类比于C语言中的数组。

访问列表中的值

1
2
3
4
5
6
7
8
9
10
11
12
13
alist = [1,2,3,4,5,6]
print alist
print alist[0]
print alist[2:]
print alist[:3]
print alist[1:3]  #左闭右开区间

#结果
[1, 2, 3, 4, 5, 6]
1
[3, 4, 5, 6]
[1, 2, 3]
[2, 3]

更新列表

1
2
3
4
5
6
7
8
alist = [1,2,3,4,5,6]
print alist
alist[0] = 10
print alist

#结果
[1, 2, 3, 4, 5, 6]
[10, 2, 3, 4, 5, 6]

删除列表中的值

1
2
3
4
5
6
7
8
alist = [1,2,3,4,5,6]
print alist
del alist[1]
print alist

#结果
[1, 2, 3, 4, 5, 6]
[1, 3, 4, 5, 6]

pop()和append()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
alist = [1,2,3,4,5,6]
print alist
alist.pop()
print alist
alist.append(30.01) #追加浮点型
print alist
alist.append('hello')   #追加字符串
print alist
alist.append(["aa","bb"])   #追加列表
print alist

#结果
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 30.01]
[1, 2, 3, 4, 5, 30.01, 'hello']
[1, 2, 3, 4, 5, 30.01, 'hello', ['aa', 'bb']]

由此可以看出，列表中可以追加任意类型的元素，十分灵活。

脚本操作符

1
2
3
4
5
6
7
Python表达式                 结果                        描述
----------------------------------------------------------------
len([1,2,3,4,5,6])          6                           判断列表中有多少个元素
[1,2,3]+[4,5,6]             [1,2,3,4,5,6]               组合
['Hi']*4                    ['Hi','Hi','Hi','Hi']       重复
3 in [1,2,3]                True                        元素是否在列表中
for x in [1,2,3]:print x    1 2 3                       迭代

列表截取


1
2
3
4
5
6
7
8
L=['SPAN','span!','spam']

操作：
Python表达式                 结果                        描述
----------------------------------------------------------------
 L[2]                       spam                    读取列表第三个元素（从0开始计数）
 L[-2]                      span!                   读取列表倒数第二个元素
 L[1:]                      ['span!','spam']        从第二个元素开始截取列表

列表函数&方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
序号              函数                           描述    
----------------------------------------------------------------
1               cmp(list1,list2)            比较两个列表的元素
2               len(list)                   列表元素个数
3               max(list)                   返回列表元素最大值
4               min(list)                   返回列表元素最小值
5               list(seq)                   将元组转换为列表

序号              方法                           描述  
----------------------------------------------------------------
1               list.append(obj)            在列表末尾添加新的对象
2               list.count(obj)             统计某个元素在列表中出现的次数
3               list.extend(seq)            在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4               list.index(obj)             从列表中找出某个值第一个匹配项的索引位置
5               list.insert(index,obj)      将对象插入列表
6               list.pop(obj=list[-1])      移除列表中的一个元素（默认最后一个元素），并返回该元素的值
7               list.remove(obj)            移除列表中某一值得第一个匹配项
8               list.reverse()              反向列表中元素
9               list.sort([func])           对原列表进行排序

元组Tuple

元组与列表相似，不同之处在于元组的元素不能修改。（可以理解为：是一个只读的列表）

访问元组

1
2
3
4
5
demotuple=(1,2,3)
print demotuple[0:2] #注意：这是一个左闭右开区间！！！

#结果：
(1, 2)

修改元组

不允许！

删除元素

不允许删除元素，可以使用del语句删除整个元组。

元素运算符

1
2
3
4
5
6
7
Python表达式                 结果                        描述
----------------------------------------------------------------
len((1,2,3,4,5,6))          6                           判断元素个数
(1,2,3)+(4,5,6)             (1,2,3,4,5,6)               连接
("Hi!")*4                    Hi!Hi!Hi!Hi!               重复，此时长度为12
3 in (1,2,3)                True                        元素是否存在
for x in (1,2,3):print x    1 2 3                       迭代

元组索引、截取

与列表截取相似。

元组内置函数

1
2
3
4
5
6
7
序号              函数                           描述    
----------------------------------------------------------------
1               cmp(tuple1,tuple2)            比较两个元组的元素
2               len(tuple)                    元组元素个数
3               max(tuple)                    返回元组元素最大值
4               min(tuple)                    返回元组元素最小值
5               tuple(list)                   将列表转换为元组

无关闭分隔符

任意无符号的对象，以逗号隔开，默认为元组。

1
2
3
4
5
6
7
print 'abc', -4.24e93, 18+6.6j,'xyz';
x, y =1,2;
print x,y;

#结果：
abc -4.24e+93 (18+6.6j) xyz
1 2

多维元组访问的示例

1
2
3
4
5
6
7
8
9
10
11
12
tuple1 =[(2,3),(4,5)]
print tuple1[0]
print tuple1[0][0]
print tuple1[0][1]
tuple2 = tuple1 + [(5)]
print tuple2

#结果：
(2, 3)
2
3
[(2, 3), (4, 5), 5]
1
2
3
4
5
6
7
8
9
10
11
12
tuple1 =[[2,3],[4,5]]
print tuple1[0]
print tuple1[0][0]
print tuple1[0][1]
tuple2 = tuple1 + [5]
print tuple2

#结果：
[2, 3]
2
3
[[2, 3], [4, 5], 5]
1
2
3
4
5
6
7
8
9
10
11
12
tuple1 =((2,3),(4,5))
print tuple1[0]
print tuple1[0][0]
print tuple1[0][1]
tuple2 = tuple1 + (5,)  #此处不能连接list,int等等类型的数据
print tuple2

#结果：
(2, 3)
2
3
((2, 3), (4, 5), 5)

字典Dictionary

字典是python中的映射数据类型，由键值(key-value)构成，类似于关联数组或哈希表。key一般以数字和字符串居多，值则可以是任意类型的python对象，如其他容器模型。字典元素用大括号{}包括。

1
2
3
4
5
dic={"key1":123,"key2":456}
print dic

#结果：
{'key2': 456, 'key1': 123}

每个键与值用冒号（:）隔开，每对用逗号分隔，整体放在花括号中。键key必须独一无二，值不需要。值value可以取任何数据类型，但必须是不可变的。

访问字典里的值

1
2
3
4
dic={"key1":123,"key2":456}
print dic['key1']

#结果： 123
1
2
3
4
5
6
7
dic={"key1":123,"key2":456}
for key in dic:
    print key,dic[key]

#结果：
key2 456
key1 123
1
2
3
4
5
6
7
dic={"key1":123,"key2":456,"key3":789}
print dic.keys()
print dic.values()

#结果：
['key3', 'key2', 'key1']
[789, 456, 123]

修改字典

向字典添加新内容的方法是增加新的键值对，修改或删除已有的键值对

1
2
3
4
5
6
dic={"key1":123,"key2":456}
dic["key1"]=5324     #如果有key1，则更新值；如果没有，则新建一个。
print dic

#结果：
{'key2': 456, 'key1': 5324}

删除字典元素

能删除单一的元素，也能清空字典。

1
2
3
4
5
6
7
8
9
10
11
12
dic={"key1":123,"key2":456,"key3":789,"key4":666}
print dic
del dic["key3"]     #删除键为key3的条目
print dic
dic.clear()         #清空词典所有条目
print dic
del dic             #删除词典

#结果：
{'key3': 789, 'key2': 456, 'key1': 123, 'key4': 666}
{'key2': 456, 'key1': 123, 'key4': 666}
{}

字典键的特性

字典值可以没有限制的取任何python对象，既可以是标准的对象，也可以是用户定义的，但是键不行。

两个点需要记住：

  • 不允许同一个键出现两次。如果同一个键被赋值两次，后一个键会被记住。

    1
    2
    3
    4
    dic={"key1":123,"key2":456,"key3":789,"key1":666}
    print dic

    #结果： {'key3': 789, 'key2': 456, 'key1': 666}

  • 键必须不可变，所以可以用数、字符串、元组充当，但是不能用列表。

字典内置函数&方法

python字典包含了一下内置的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
序号              函数                           描述    
----------------------------------------------------------------
1               cmp(dict1,dict2)                比较两个字典的元素
2               len(dict)                       计算字典元素个数，即键的总数
3               str(dict)                       输出字典可打印的字符串表示
4               type(variable)                  返回输入的变量类型，如果变量是字典就返回字典类型

序号              方法                                   描述  
----------------------------------------------------------------
1               radiansdict.clear()                     删除字典内的所有元素
2               radiansdict.copy()                      返回一个字典的浅复制
3               radiansdict.fromkeys(seq,value))        创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值
4               radiansdict.get(key,default=None)       返回指定键的值，如果键不存在则返回default的值
5               radiansdict.has_key(key)                如果字典里有该键，则返回true，否则返回false
6               radiansdict.items()                     以列表返回可遍历的（键，值）元组数组
7               radiansdict.keys()                      以列表返回一个字典里的所有的键
8               radiansdict.setdefault(key,default=None)和get()相似，但如果不存在，则会添加键并设置值为default
9               radiansdict.update(dict2)               把字典dic2的键值对更新到dict中
10              radiansdict.values()                    以列表返回字典中所有的值

本文标题:python的基础数据类型

文章作者:Jerry

发布时间:2018年01月31日 - 11:09:51

最后更新:2018年03月17日 - 00:08:52

原始链接:https://jerryma0912.github.io/2018/01/31/4-python-datastruct/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。