这篇博客详细介绍了Python中的基本变量类型，包括整型（integer）、浮点型（float）、字符串（string）、列表（list）、元组（tuple）、字典（dict）和集合（set）。重点讨论了整除和除法的差异，字符串的转义符号，以及各种类型的操作，如添加、删除和访问元素。此外，还提到了Python中不同版本的默认编码差异以及类型之间的转换和访问规则。
简介
本文主要介绍python中的基本变量类型。看过了慕课网的教程后，再次回顾，记录一下第一次学习没有注意到的地方以及容易出错的地方，加深理解和记忆。
integer & float
在python3.x版本中，需要注意一下整数和浮点数的运算。（若在2.x环境下，可先引入3.x环境。 from __ future__ import division）
整除：//
-
如果除数和被除数均为integer（无float），则返回integer类型。
10 // 2 => 5
10 // 3 => 3 -
如果除数和被除数中有float，则返回float类型。
10.0 // 2 => 5.0
10 // 2.0 => 5.0
10.0 // 2.0 => 5.0
———————
10.0 // 3 => 3.0
10 // 3.0 => 3.0
10.0 // 3.0 => 3.0
除法： /
- 总是返回float类型。
10 / 2 => 5.0
10.0 / 2 => 5.0
10 / 2.0 => 5.0
10.0 / 2.0 => 5.0
———————
10 / 3 => 3.3333333333333335
10.0 / 3 => 3.3333333333333335
10 / 3.0 => 3.3333333333333335
10.0 / 3.0 => 3.3333333333333335
string
-
转义符号：
\n 换行
\t 制表符
\ 转义符本身 -
不转义字符串： r’(_)/ (_)/’
-
多行字符串： ‘’‘string’’’
’’‘Line 1
Line 2
Line 3’’'
等同于
"Line 1\nLine 2\nLine 3" -
Unicode字符串标记：# -*- coding: utf-8 -*- 或者 字符串前加u标记
注：经过我自己的测试，python2.x版本下的默认编码是ascii，python3.7的默认编码是utf-8，如果默认编码已经是utf-8，就不需要重复声明了。
检测方式如下：
import sys
print(sys.getdefaultencoding())
注：多行字符串在起始处要避免连用6个单引号，否则报错invalid syntax，在结尾处要避免连用多于3个单引号，否则报错EOL while scanning string literal。 因python检测到3个连续单引号就认为多行字符串起始，后续再次检测到3个连续单引号就认为EOL此行结束，因此，如果多行字符串起始处连续用5个单引号，python会认为后2个是字符串内的文本，如果在起始处连用6个单引号，python将认为此多行字符串刚开始就结束了，内容为空，后续再检测到其它内容就是无效语句了。如果多行字符串在结尾处连续使用4个字符串，python检测到前3个就认定为字符串结束了，因此检测到第4个单引号时，会报错“在扫描字符时检测到结束标记”。因此多行字符串内首尾处需要引用的，建议使用双引号避免出错，若使用单引号，则一定注意起始处连续使用单引号不要超过6个（含），结尾处不可以多于3个。
例：
>>>print(r''''''To be, or not to be': that is the question.
...Whether it's nobler in the mind to suffer.''')
SyntaxError: Invalid syntax
>>>print(r'''To be, or not to be': that is the question.
...Whether it's nobler in the mind to 'suffer.'''')
SyntaxError: EOL while scanning string literal
list
- 创建list
l = ['a', 'b', 'c', 88, 'b']
总结：list的标志是方括号[ ]括起来。list内元素可以有不同类型。
- 添加/插入/删除/替换
l.append('a')
print(l)
=>['a', 'b', 'c', 88, 'b', 'a']
l.insert(1,'z')
print(l)
=>['a', 'z', 'b', 'c', 88, 'b', 'a']
l.pop()
=> 'a'
print(l)
=> ['a', 'z', 'b', 'c', 88, 'b']
l.pop(2,3,4)
=>TypeError: pop() takes at most 1 argument (3 given)
l.pop(4)
=> 88
print(l)
=> ['a', 'z', 'b', 'c', 'b']
l[0] = 'b'
print(l)
=> ['b', 'z', 'b', 'c', 'b']
总结：append将新元素添加在原list最后，insert将新元素添加至原list的指定索引位置，后续元素依次向后挪动。pop删除list中的一个元素，并返回被删除的元素，无参数时删除最后一个，有参数时删除对应索引上的元素。替换元素时，直接将新元素传至对应索引即可。
- 访问/查询
print(l)
=>['a', 'z', 'b', 'c', 88, 'b', 'a']
print(l(0))
=>TypeError: 'list' object is not callable
print(l[0])
=>'a'
print(l[-2])
=>'b'
总结：在python中，变量后加圆括号( )代表调用。（推测）有序的可迭代对象均用方括号[ ]来实现。可以倒序访问。
- 交换元素
print(l)
=>['a', 'z', 'b', 'c', 88, 'b', 'a']
l[0],l[1] = l[1],l[0]
print(l)
['z', 'a', 'b', 'c', 88, 'b', 'a']
总结：这是python中独有的交换变量的方式，类似于ES6的解构赋值语法，另外也可以引入临时变量。在两个变量均为integer类型的情况下，还可以进行加减或者用位运算来实现。详例如下（为方便表示，用两个变量来代替）：
a = 1
b = 2
a = a + b //a = 3
b = a - b //b = 1
a = a - b //a = 2
print(a,b)
2 1
a = 1
b = 2
a = a ^ b //a = 3
b = a ^ b //b = 1
a = a ^ b //a = 2
print(a,b)
2 1
此两种方法，看起来相似，原理却不同。下例为证，请自行研究。
a = 500
b = 1100
a = a ^ b //a = 1464
b = a ^ b //b = 500
a = a ^ b //a = 1100
print(a,b)
1100 500
a = -500
b = -123
a = a ^ b //a = 393
b = a ^ b //b = -500
a = a ^ b //a = -123
print(a,b)
-123 -500
tuple
- 创建
t1 = 0,1,2,3,4,5
t2 = (0,1,2,3,4,5)
l = [0,1,2,3,4,5]
t3 = tuple(l)
l3 = list(t3)
t4 = ()
t5 = 1, //逗号作用在于和普通变量区别
t6 = (4,) //逗号作用在于和运算优先级的圆括号区别
总结：将多个变量以逗号隔开同时赋值给一个变量，默认生成tuple类型。list和tuple之间可以互相转换。当定义一个只含有一个元素的tuple时，要在末尾加上逗号，以区分运算优先级的圆括号。
- 添加/插入/删除
t = 1,2,3,[1,2,3]
print(t)
=> (1, 2, 3, [1, 2, 3])
t[0] = 2
=> TypeError: 'tuple' object does not support item assignment
t.append('s')
=> AttributeError: 'tuple' object has no attribute 'append'
t.insert(1,'asdf')
=> AttributeError: 'tuple' object has no attribute 'insert'
t[3][0] = 100
print(t)
=> (1, 2, 3, [100, 2, 3])
总结：tuple一旦定义，即不可变，除非其中含有可变元素，即如果tuple中的string或integer等简单类型均不可变，但其中的list是可变的。
注：此处的例子仍需注意，具体原理请参考大神的分析。
- 访问
t = 1,2,3
print(t)
=> (1,2,3)
print(t[0])
=> 1
print(t[-1])
=> 3
总结： tuple为有序集合，tuple也用中括号[ ]来访问对应索引位置上的元素，tuple也支持倒序查询。
dict
- 创建
d1 = {
'Adam':95,
'Lisa':85,
'Bart':59,
'Paul':75
}
print(d1)
=> {'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}
len(d1)
=> 4
d2 ={['Alex']: 80}
=> TypeError: unhashable type: 'list'
总结：dict为key-value一一对应形式的集合，一对键和值视为一个元素。dict无序。dict的key必须为不可变类型。
- 添加/插入/删除
d = {'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 75}
d['Red'] = 60
print(d)
=> {'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 75, 'Red': 60}
- 访问
d = {'Adam': 95, 'Lisa': 85, 'Bart': 59, 'Paul': 75}
print(d['Adam'])
=> 95
print(d['Alex'])
=> KeyError: 'Alex'
print(d.get('Adam'))
=> 95
print(d.get('Alex'))
=> None
d['Adam'].set(12)
=> AttributeError: 'int' object has no attribute 'set'
d.set('Adam',12)
AttributeError: 'int' object has no attribute 'set'
=> AttributeError: 'dict' object has no attribute 'set'
总结：dict也用中括号[ ]来访问对应索引的元素。如果直接print一个不存在的key的值，会返回KeyError，为避免错误，可以用dict自带的get方法，可惜没有set方法，可能是因为set在python中是一个类型。（虽然没有set方法，但有setdefault，自行查找。）
set
- 创建
s1 = {'Adam', 'Lisa', 'Bart', 'Paul'}
print(type(s1))
=><class 'set'>
print(s1)
=>{'Paul', 'Lisa', 'Adam', 'Bart'}
l2 = ['Adam', 'Lisa', 'Bart', 'Paul']
s2 = set(l2)
print(type(s2))
=><class 'set'>
print(s2)
=>{'Paul', 'Lisa', 'Adam', 'Bart'}
l2 = list(s2)
print(l2)
=> ['Adam', 'Lisa', 'Bart', 'Paul']
type(l2)
=><class 'list'>
s3 = {'Adam',['Adam']}
=> TypeError: unhashable type: 'list'
总结：set无序。set可以和list互相转换。set存储的元素和dict的key类似，必须是不变对象。
- 添加/删除（因为无序，所以无所谓插入，等同于添加）
s = {1, 2, 3}
s.add(4)
print(s)
{1, 2, 3, 4}
s.add(3)
print(s)
{1, 2, 3, 4}
s.remove(2)
print(s)
{1, 3, 4}
s.remove(2)
=>KeyError: 2
总结：set内的元素不能重复，添加已存在元素时，不报错，但set维持原状；删除不存在元素时，报KeyError错误。
- 访问
s = {1, 2, 3}
2 in s
=> True
总结：set因为无序，又无key，无法直接访问，一般用于判断某元素是否存在于set中，比如检测用户输入的字符是否合法。
补充：关于类型的hashable问题，可参考此篇文章
后记
写此篇文章时，笔者只是python的初学者，在查询资料过程中发现仍有太多内容无法整理在此，以后慢慢补充。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
