python学习之路二：基本数据类型

本节重点

理解什么是变量？
掌握各种数据类型
理解可变类型和不可变类型

一.变量和常量

变量：

作用：存贮程序的中间结果在内存里，以备后边的程序调用

定义规范：

变量名只能是字母、数字活下划线的任意组合

变量名的第一个字符不能是数字

python中的关键字不能作为变量名

命名习惯：

驼峰体 FilePath

下划线体 file_path（官方推荐）

不建议的命名习惯：

变量名为中文、拼音

变量名过长

变量名词不达意

与c#对比：不需要定义变量的类型

变量的应用：

a=1

b=a # 给变量b赋值变量a的内存地址，该内存地址指向1

a=2 # 修改a的内存地址指向2，但是变量b的内存地址不变

print(a) #2

print(b) #1

常量：

特点：常量即指不变的量，如pai 3.141592653，或在程序运行过程中不会改变的量

在python中没有一个专门的语法代表常量，规范使用变量名全部大写代表常量

二.什么是数据类型？python中有哪些数据类型？

我们人类可以很容易的愤青数字和字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻。除非你明确的告诉它，1 是数字，“中国”是文字，否则它分不清1和“中国”的区别。因此，每种编程语言里都有数据类型，用来对数据进行明确的划分。

python中的数据类型按可分为两种：基本类型和数据集

python中的基本类型有：Number（数字类型）、String（字符串类型）

python中的数据集有：List（列表类型）、Tuple（元祖类型）、Dict（字典类型）、Set（集合类型）

三.Number类型

Number类型有：int（整型）、float（浮点型）、complex（复数型）、bool（布尔型）

int

int用来表示整数，在32位操作系统中，它的取值范围为 -2*31~2*32-1，在64位操作系统中它的取值范围为-2*61~2*61-1

定义：变量名 = 值（数字）

变量名 = int(值)

float

float用来表示小数

定义：变量名 = 值（小数）

变量名 = float(小数)

精度问题：

获取更高的精度：借助decimal模块的“getcontext“和“Decimal“ 方法

from decimal import *

getcontext().prec = 50  # 设置精度为50位精准精度a = Decimal(1)／Decimal(3)#注，在分数计算中结果正确，如果直接定义超长精度小数会不准确

#a 的值为 Decimal('0.33333333333333333333333333333333333333333333333333')

complex

complex用来表示复数

定义：变量名 = a + bj

变量名 = complex(a,b)
bool

bool用来表示对/错，bool类型只有两个值 True/False。0/1，空集合/有值集合也可以用来表示bool的True/False。

四.String类型

文本str

字节bytes

在python中加了引号的字符都被认为是字符串。

单引号、双引号：无明显差别，根据字符串内容选择。 strval = '我是"小明"',strval2 = "I'm xiaoming"。不支持自动换行，需要再结尾加。

多引号：支持自动换行。字符串内容中既有'又有"时使用。

字符串格式化：%s（string） %d（int） %f（floag）占位符、 % 连接符

info = """

        ------info of %s ------

        Name:     %s

        Age:      %s

        Job：      %s

        HomeTown  %s

        --------- end ---------

        """ %(name,age,job,hometown)

常用操作

#索引

s = 'hello'

>>> s[1]

'e'

>>> s[-1]

'o'

>>> s.index('e')

1

#查找

>>> s.find('e')

1

>>> s.find('i')

-1

#移除空白

s = '  hello,world!  '

s.strip()

s.lstrip()

s.rstrip()

s2 = '***hello,world!***'

s2.strip('*')

#长度

>>> s = 'hello,world'

>>> len(s)

11

#替换

>>> s = 'hello world'

>>> s.replace('h','H')

'Hello world'

>>> s2 = 'hi，how are you？'

>>> s2.replace('h','H')

'Hi，How are you？'

#切片

>>> s = 'abcdefghigklmn'

>>> s[0:7]

'abcdefg'

>>> s[7:14]

'higklmn'

>>> s[:7]

'abcdefg'

>>> s[7:]

'higklmn'

>>> s[:]

'abcdefghigklmn'

>>> s[0:7:2]

'aceg'

>>> s[7:14:3]

'hkn'

>>> s[::2]

'acegikm'

>>> s[::-1]

'nmlkgihgfedcba'

五.List类型

list列表，可以用来贮存所有类型的对象的有序集合。

定义：[]内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素

1.列表的创建

list_test=[‘张三‘,‘李四’,'alex']

#或

list_test=list('alex')

#或

list_test=list([‘张三‘,‘李四’,'alex'])

2.列表的特点和常用操作

特性：a.可以存放多个值

b.按照从左到右的顺序定义列表元素，下标从0开始顺序访问，有序

常用操作：

#索引

>>> l = ['egon','alex','seven','yuan']

>>> l[0]

'egon'

>>> l[2]

'seven'

#切片

>>> l[0:2]

['egon', 'alex']

>>> l[2:5]

['seven', 'yuan']

>>> l[:2]

['egon', 'alex']

>>> l[2:]

['seven', 'yuan']

>>> l[:]

['egon', 'alex', 'seven', 'yuan']

>>> l[::2]

['egon', 'seven']

>>> l[::-1]

['yuan', 'seven', 'alex', 'egon']

#追加

>>> l.append("eva")

>>> l

['egon', 'alex', 'seven', 'yuan', 'eva']

#删除

>>> l.remove('eva')

>>> l

['egon', 'alex', 'seven', 'yuan']

>>> l.pop()

'yuan'

>>> l

['egon', 'alex', 'seven']

>>> l.pop(2)

'seven'

>>> l

['egon', 'alex']

#长度

>>> len(l)

3

#包含

>>> 'seven' in l

True

>>> 'yuan' in l

False

#循环:为什么是“i”？

>>> for i in l:

    print(i)

egon

alex

seven

3.列表和字符串

列表转字符串：str1 = "".join(list1)

字符串转列表：l2 = list(str1)或者l2 = str2.split(',')

补充：range(n) 生成区间为[0,n)的list集合，常用于for循环

六.tuple类型

元组与列表类似，是不可变的列表

特性：

1.可存放多个值

2.不可变

3.按照从左到右的顺序定义元组元素，下标从0开始顺序访问，有序

元组的创建和常用操作

创建

ages = (11, 22, 33, 44, 55)

#或

ages = tuple((11, 22, 33, 44, 55))

常用操作

#索引

>>> ages = (11, 22, 33, 44, 55)

>>> ages[0]

11

>>> ages[3]

44

>>> ages[-1]

55

#切片:同list　　

#循环

>>> for age in ages:

    print(age)

11

22

33

44

55

#长度

>>> len(ages)

5

#包含

>>> 11 in ages

True

>>> 66 in ages

False

>>> 11 not in ages

False

元组特性详解

1.可存放多个值

如果元组中只有一个值 t = (1,)

元祖中不仅可以存放数字、字符串，还可以存放更加复杂的数据类型

2.不可变

元组本身不可变，如果元组里存放了其他可变元素，这些可变元素可以改变

七.dict类型

字典是python语言中唯一的映射类型。注：字典的查找效率要比list、tuple高

定义：{key1:value1,key2:value2}

说明：1.键与之用冒号“:”分开

2.项与项用“,”分开

特性：

 1.key-value结构

2.key必须可hash，且必须为不可变数据类型，必须唯一

3.可存放任意多个值、可修改、可以不唯一

4.无序

字典的创建和常用操作

#字典的创建

person = {"name": "alex", 'age': 20}

#或

person = dict(name='seven', age=20)

#或

person = dict({"name": "egon", 'age': 20})

#或

person = dict((['name','苑昊'],['文周',18]))

{}.fromkeys(seq,100) #不指定100默认为None

#注意

>>> dic={}.fromkeys(['k1','k2'],[])

>>> dic

{'k1': [], 'k2': []}

>>> dic['k1'].append(1)

>>> dic

{'k1': [1], 'k2': [1]}

#字典的常见操作

键、值、键值对

　　　　1、dic.keys() 返回一个包含字典所有KEY的列表；

　　　　2、dic.values() 返回一个包含字典所有value的列表；

　　　　3、dic.items() 返回一个包含所有（键，值）元祖的列表；

　　　　4、dic.iteritems()、dic.iterkeys()、dic.itervalues() 与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表；

新增

　　　　1、dic['new_key'] = 'new_value'；

　　　　2、dic.setdefault(key, None) ,如果字典中不存在Key键，由 dic[key] = default 为它赋值；_

删除

　　　　1、dic.pop(key[,default]) 和get方法相似。如果字典中存在key，删除并返回key对应的vuale；如果key不存在，且没有给出default的值，则引发keyerror异常；

　　　　2、dic.clear() 删除字典中的所有项或元素；

修改

　　　　1、dic['key'] = 'new_value',如果key在字典中存在，'new_value'将会替代原来的value值；

　　　　2、dic.update(dic2) 将字典dic2的键值对添加到字典dic中

查看

　　　　1、dic['key']，返回字典中key对应的值，若key不存在字典中，则报错；

　　　　2、dict.get(key, default = None) 返回字典中key对应的值，若key不存在字典中，则返回default的值（default默认为None）

循环

　　　　1、for k in dic.keys()

　　　　2、for k,v in dic.items()

　　　　3、for k in dic

长度

　　　　1、len(dic)

八.集合类型

集合是一个数学的概念，由一个或者多个确定的元素所构成的整体叫做集合

特性：

1.确定性

2.互异性（去重）

3.无序性

集合的定义:

#可变集合

s = {1,2,3,4}

#不可变集合

s = frozenset({1,2,3,4})

集合的运算关系

 1.交集

l= {'张三','李四','老男孩'}

p = {'张三','李四','alex'}

print(l.intersection(p))

print(l&p)

　　2.合集

l= {'张三','李四','老男孩'}

p = {'张三','李四','alex'}

print(l.union(p))

print(l|p)

　　3.并集

l= {'张三','李四','老男孩'}

p = {'张三','李四','alex'}

print(l.difference(p))

print(l-p)

　　4.对称差集

a = {1,2,3}

b = {2,3,4,5}

print(a.symmetric_difference(b))

print(a^b)

　　5.包含关系

in,not in：判断某元素是否在集合内

＝＝,！＝:判断两个集合是否相等

　集合的常见操作

　　1.增加

　　　　单个元素的增加 : add()，add的作用类似列表中的append

　　　　对序列的增加 : update()，而update类似extend方法，update方法可以支持同时传入多个参数：

>>> a={1,2}

>>> a.update([3,4],[1,2,7])

>>> a

{1, 2, 3, 4, 7}

>>> a.update("hello")

>>> a

{1, 2, 3, 4, 7, 'h', 'e', 'l', 'o'}

>>> a.add("hello")

>>> a

{1, 2, 3, 4, 'hello', 7, 'h', 'e', 'l', 'o'}

　　2.删除　　　

　　　　集合删除单个元素有两种方法：

　　　　元素不在原集合中时：

　　　　set.discard(x)不会抛出异常

　　　　set.remove(x)会抛出KeyError错误

>>> a={1,2,3,4}

>>> a.discard(1)

>>> a

{2, 3, 4}

>>> a.discard(1)

>>> a

{2, 3, 4}

>>> a.remove(1)

Traceback (most recent call last):

  File "<input>", line 1, in <module>

KeyError: 1

　　　　pop()：由于集合是无序的，pop返回的结果不能确定，且当集合为空时调用pop会抛出KeyError错误，

　　　　clear():清空集合

>>> a={3,"a",2.1,1}

>>> a.pop()

>>> a.pop()

>>> a.clear()

>>> a

set()

>>> a.pop()

Traceback (most recent call last):

  File "<input>", line 1, in <module>

KeyError: 'pop from an empty set'

九.可变类型和不可变类型

　　通过操作修改该类型的实例，内存地址保持不变得是可变类型