学习2: 数据类型和变量

Posted 2020-08-29

1. 变量

Python 变量仅是名称。变量名的创建是通过把类型的实例赋值给它们。变量本身并没有类型，而与它们绑定在一起的对象拥有类型。

名称只是个标签，同样，它也可以被一个完全不同的对象重新赋值。赋值操作使用=操作符，所以把一个值赋给一个变量就如下所示：

aVariable = aValue

这段代码把值aValue 绑定到变量名aVariable 上。如果此变量名不存在，解释器会把这个名称添加到合适的命名空间中。

因此，在Python 中区别变量和它指向的对象是非常重要的。

1) 变量判断： is 和 ==

is判断两个变量是否指向同一个变量,  ==判断两个变量指向的对象是否相等

>>> aString = ‘I love spam‘
>>> anotherString = ‘I love spam‘
>>> anInt = 6
>>> intAlias = anInt
>>> aString == anotherString # test equality of value
True
>>> aString is anotherString # test object identity
False
>>> anInt == intAlias # same value
True
>>> anInt is intAlias # also same object identity
True

2)  变量种类: 全局变量和局部变量

例如1： 

name=‘tom‘
def test():
    print name
					
test()

输出：
tom
[Finished in 0.2s]
说明：函数中可以直接使用全局变量，打印name时候查找name变量，先查找局部name没有找到，再查找全局name，找到了然后输出。

例如2：

name=‘tom‘
def test2():
    if name == ‘tom‘:
        pass
    else:
　　　　name = ‘liming‘
    print name
test2() 

执行报错:UnboundLocalError: local variable ‘name‘ referenced before assignment
说明：函数中先引用name判断是否等于‘tom‘，先找局部name没有找到，然后再找全局name找到了，所以使用全局name判断，然后else中又对这个全局name进行赋值，所以报错。
如果函数中的变量是引用的全局变量，那么函数不能对该变量直接重新赋值，如果必须重新赋值那么需要在函数中先通过global引用，如下

例如3：

name=‘tom‘
def test2():
    global name
    if name == ‘tim‘:
        pass
    else:
　　　　name = ‘liming‘
    print name
test2()
print name    

正常输出:
liming
liming
[Finished in 0.2s]
说明：这个函数中通过使用global引用了全局name，所以在函数中可以对该全局name重新赋值。重结果中可以看到全局name的值已经被修改

例如4：

name=‘tom‘
def test2():
    name = ‘liming‘
    print name
test2()
print name

正常输出：
liming
tom
[Finished in 0.3s]
说明：此处在函数中直接定义了一个局部name，注意这个是定义局部变量而不会查找全局变量。局部变量和全局变量都可以正常输出，互不影响。

 

2. 数值类型: 整数和浮点数

3. 布尔类型

在Python中 None,  False, 空字符串"", 0, 空列表[], 空字典{}, 空元组()都相当于False：

>>> bool()
False
>>> int(bool())
0
>>> int(True)
1
>>> int(False)
0

4. 空值类型None

空值是Python里一个特殊的值，用None表示。所有对None对象的引用都是同一个实例

>>> a=None
>>> b=None
>>> a==b
True
>>> a is b
True

5. 字符串

 

6. 列表

1) list是一种有序的集合，可以随时添加和删除其中的元素; 空列表定义a=[]

2) 可以用索引访问其中某一个元素，索引从0开始；当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，最后一个元素的索引是len(a) - 1
    如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素,以此类推，可以获取倒数第2个、倒数第3个

3）可以通过切片访问其中的多个元素
4) list相关函数，可以通过help(list)查看

list相关操作：

添加

append(元素) : 末尾添加元素
extend(列表) : 合并另外一个列表
insert(索引位置，元素): 在某个位置插入元素

>>> a=[2,1,2]
>>> a[0]=3		    
>>> a
[3, 1, 2]
>>> b
[4, 7, 6, 10]
>>> a.append(5)
>>> a
[3, 1, 2, 5]
>>> a.extend(b)
>>> a
[3, 1, 2, 5, 4, 7, 6, 10]
>>> a.insert(0,9)
>>> a
[9, 3, 1, 2, 5, 4, 7, 6, 10]
>>> a.insert(1,8)
>>> a
[9, 8, 3, 1, 2, 5, 4, 7, 6, 10]
>>> a.insert(5,1)
>>> a
[9, 8, 3, 1, 2, 1, 5, 4, 7, 6, 10]　　

注： 两个列表相并除了用extend方法，用+可以扩展另外一个列表，用*可以扩展自身列表

>>> a=[1,2]
>>> b=[3,4]
>>> a+b
[1, 2, 3, 4]
>>> a*2
[1, 2, 1, 2]

　　

删除：
remove(元素): 删除指定元素，如果有多个相同元素只删除第一个；
pop(索引位置): 删除指定位置元素，如果不指定表示删除最后一个元素；

del:

注意三者之间的区别.

>>> a
[9, 8, 3, 1, 2, 1, 5, 4, 7, 6, 10]
>>> a.remove(1)
>>> a
[9, 8, 3, 2, 1, 5, 4, 7, 6, 10]
>>> a.pop(0)
9
>>> a
[8, 3, 2, 1, 5, 4, 7, 6, 10]
>>> a.pop()
10
>>> a
[8, 3, 2, 1, 5, 4, 7, 6]

>>> a=[8, 7, 6, 6, 5, 4, 3, 2, 1]
>>> b=a
>>> del a[0]
>>> a
[7, 6, 6, 5, 4, 3, 2, 1]
>>> b
[7, 6, 6, 5, 4, 3, 2, 1]
>>> del a
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name ‘a‘ is not defined
>>> b
[7, 6, 6, 5, 4, 3, 2, 1]　

 

修改：
直接根据列表索引位置重新赋值即可，注意首先必须保证索引位置没有超出列表的索引范围；
>>> a=[]
>>> a[0]=3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range

 

查询：
index(元素): 根据元素内容查询其所在的索引位置;
count(元素）: 统计某个元素在列表中有多少个；
index和count的区别： 两者都可以用来查询列表元素，如果元素不在列表中的话index会出现异常，而count会返回0

len(列表): 统计列表的长度，也就是有多少个元素；
sort():
reverse():

>>> a
[8, 3, 2, 1, 5, 4, 7, 6]
>>> a.index(1)
3
>>> a.insert(2,6)
>>> a
[8, 3, 6, 2, 1, 5, 4, 7, 6]
 >>> a.count(3)
1
>>> a.count(6)
2
>>> a.sort()
>>> a
[1, 2, 3, 4, 5, 6, 6, 7, 8]
>>> a.reverse()
>>> a
[8, 7, 6, 6, 5, 4, 3, 2, 1]
>>> len(a)
9

 

判断某个元素是否存在于列表中也可以使用in的方法

循环遍历列表：

while

for

 

7. 元组

1) tuple称为元组，有序但是元素不可变更，一旦初始化之后就不能再修改；空元组定义为 a=()
2) tuple也可以通过索引访问某一个元素，索引从0开始
3) tuple相关函数：
index（元素): 和列表相同也是根据元祖内容查询它的索引位置；
count(元素): 和列表一样也是统计某个元素出现的次数；
index和count的区别： 两者都可以用来查询tuple元素，如果元素不在tuple中的话index会出现异常，而count会返回0

>>> m=(6,8,10,6)
>>> m.count(6)
2
>>> m.count(10)
1
>>> m.index(10)
2
>>> m.index(6)
0　

 

>>> a=(1,2,3,4)
>>> a.index(0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.count(0)
0
>>> a.index(1)
0
>>> a.count(1)
1
>>> 　　

4) 只有一个元素的元组，定义为a=(1,)，不能定义为a=(1);

>>> a=(1,)
>>> type(a)
<type ‘tuple‘>
>>> a=(1)
>>> type(a)
<type ‘int‘>

5) 元组的不可变更是指元组的元素指向不可更新，如果元素指向某个列表的时候，列表的内容更新不受限制；

>>> m=(1,2)
>>> m
(1, 2)
>>> a=[‘a‘,‘b‘]
>>> m=(1,2,a)
>>> m
(1, 2, [‘a‘, ‘b‘])
>>> a.append(‘c‘)
>>> a
[‘a‘, ‘b‘, ‘c‘]
>>> m
(1, 2, [‘a‘, ‘b‘, ‘c‘])

　　

8. 字典

9. 集合