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（布尔型）

1. int

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

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

   变量名 = int(值)

2. float

   float用来表示小数

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

   变量名 = float(小数)

   精度问题：

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

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

   　　

3. complex

       complex用来表示复数

   定义：变量名 = a + bj

   变量名 = complex(a,b)

4. 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'

　　

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

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