python3_03.数据类型

发布时间：2019-09-24 08:29:48编辑：auto阅读（1568）

1.数据类型

    Python3 中有六个标准的数据类型：

    1.1、Number（数字）

        int、float、bool、complex（复数）。

      注意：不同类型的数混合运算时会将整数转换为浮点数

---

    1.2、String（字符串）

       Python中的字符串用单引号(')或双引号(")括起来，同时使用反斜杠(\)转义特殊字符。

       Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。

    注意：

• • 反斜杠可以用来转义，使用r可以让反斜杠不发生转义，r'\temp' 。

  • 字符串可以用+运算符连接在一起，用*运算符重复。

  • Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。

  • Python中的字符串不能改变。




str.upper()	全部大写
str.lower()	全部小写
str.swapcase()	大小写转换
str.capitalize()	首字母大写
str.title()	每个单词的首字母大写
str.find('t',start,end)	查找字符串，可以指定起始及结束位置搜索,没有返回-1
str.rfind('t')	从右边开始查找字符串
str.replace('old','new')	替换函数，替换old为new，参数中可以指定maxReplaceTimes，即替换指定次数的old为new
str.strip()	去两边空格
str.lstrip()	去左空格
str.rstrip()	去右空格
str.startswith('start')	是否以start开头
str.endswith('end')	是否以end结尾
str.isalnum()	是否全为字母或数字
str.isalpha()	是否全字母
str.isdigit()	是否全数字
str.islower()	是否全小写
str.isupper()	是否全大写

    

   #print字符串拼接:
    >>> print("hello"+"andy")
    helloandy
    >>> print("hello","andy")
    hello andy    <,号会有一个空格>
    >>> print("hello"*2)
    hellohello
  #join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
    >>> list=['I','love','you']
    >>> ''.join(list)
    'Iloveyou'
    >>> ' '.join(list)
    'I love you'
    >>> ','.join(list)
    'I,love,you'
    >>> love = 'I love you'
    >>> love.split()      #默认是以空格为分隔符分割
    ['I', 'love', 'you']
    >>> love.split(' ',2)   #以空格为分隔符，最大分割次数为2
    ['I', 'love', 'you']
    >>> love.split(' ',1)   #以空格为分隔符，最大分割次数为1
    ['I', 'love you']




转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy代表的字符，例如：\o12代表换行
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

 #python字符串格式化:
   "this is %d %s bird" % (1, 'dead')             # 一般的格式化表达式
   "%s---%s---%s" % (42, 3.14, [1, 2, 3])          # 字符串输出：'42---3.14---[1, 2, 3]'
   "%d...%6d...%-6d...%06d" % (1234, 1234, 1234, 1234) # 对齐方式及填充："1234...  1234...1234  ...001234"
   x = 1.23456789
   "%e | %f | %g" % (x, x, x)                 # 对齐方式："1.234568e+00 | 1.234568 | 1.23457"
   "%6.2f*%-6.2f*%06.2f*%+6.2f" % (x, x, x, x)      # 对齐方式：'  1.23*1.23  *001.23* +1.23'
   "%(name1)d---%(name2)s" % {"name1":23, "name2":"value2"}    # 基于字典的格式化表达式
   "%(name)s is %(age)d" % vars()               # vars()函数调用返回一个字典，包含了所有本函数调用时存在的变量
  "{0}, {1} and {2}".format('spam', 'ham', 'eggs')    # 基于位置的调用
   "{motto} and {pork}".format(motto = 'spam', pork = 'ham')   # 基于Key的调用
   "{motto} and {0}".format(ham, motto = 'spam')            # 混合调用
   # 添加键 属性 偏移量 (import sys)
   "my {1[spam]} runs {0.platform}".format(sys, {'spam':'laptop'})      # 基于位置的键和属性
   "{config[spam]} {sys.platform}".format(sys = sys, config = {'spam':'laptop'})   # 基于Key的键和属性
   "first = {0[0]}, second = {0[1]}".format(['A', 'B', 'C'])         # 基于位置的偏移量
   # 具体格式化
   "{0:e}, {1:.3e}, {2:g}".format(3.14159, 3.14159, 3.14159)   # 输出'3.141590e+00, 3.142e+00, 3.14159'
    "{fieldname:format_spec}".format(......)
   # 说明:
   """
       fieldname是指定参数的一个数字或关键字, 后边可跟可选的".name"或"[index]"成分引用
       format_spec ::=  [[fill]align][sign][#][0][width][,][.precision][type]
       fill        ::=  <any character>              #填充字符
       align       ::=  "<" | ">" | "=" | "^"        #对齐方式
       sign        ::=  "+" | "-" | " "              #符号说明
       width       ::=  integer                      #字符串宽度
       precision   ::=  integer                      #浮点数精度
       type        ::=  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"
   """
   # 例子:
       '={0:10} = {1:10}'.format('spam', 123.456)    # 输出'=spam       =    123.456'
       '={0:>10}='.format('test')                    # 输出'=      test='
       '={0:<10}='.format('test')                    # 输出'=test      ='
       '={0:^10}='.format('test')                    # 输出'=   test   ='
       '{0:X}, {1:o}, {2:b}'.format(255, 255, 255)   # 输出'FF, 377, 11111111'
       'My name is {0:{1}}.'.format('Fred', 8)       # 输出'My name is Fred    .'  动态指定参数

符 号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串： 'a %s parrot' % 'kind'
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

---

    1.3、List（列表）

    注意：

    1、List写在方括号之间，元素用逗号隔开。

    2、和字符串一样，list可以被索引和切片。

    3、List可以使用+操作符进行拼接，星号（*）是重复操作。

    4、List中的元素是可以改变的。

list=[]	创建一个空列表
list.append('zengjia')	在列表末尾添加一个元素，返回值为none
list.extend([7,8,9])	extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
list.insert(6,'six')	指定位置插入
del list[6]	删除指定位置元素   del a[2:4]  del a[:]
list.pop()	删除指定位置的值并返回删除的值 默认最后一个
list.clear()	清空列表
list.sort()	排序
list.reverse()	原地反转列表
list.remove(1)	删除首次出现的指定元素 1
list.index(22)	查看元素第一次出现的位置
list.count(1)	指定元素1出现的次数
list.copy()	返回列表的浅复制，等于a[:]。
len(list)	列表长度
切片：用切片查看元素不会因为越界抛出异常，代码具有更强的健壮性
cc=[0,1,2,3,4,5,6,7,8,9,10]
cc[::]	[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
cc[0:11:1]	[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
cc[::-1]	[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
cc[::2]	[0, 2, 4, 6, 8, 10]
cc[len(cc):]='a'  #切片增加元素	[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a']
cc[:3]=['a','b','c'] #切片修改元素	['a', 'b', 'c', 3, 4, 5, 6, 7, 8, 9, 10]
collections.deque	它为在首尾两端快速插入和删除而设计。
for i, v in enumerate(['tic', 'tac', 'toe']): ...     print(i, v)	在序列中循环时，索引位置和对应值可以使用 enumerate() 函数同时得到:
>>> questions = ['name', 'quest', 'favorite color'] >>> answers = ['lancelot', 'the holy grail', 'blue'] >>> for q, a in zip(questions, answers): ...     print('What is your {0}?  It is {1}.'.format(q, a))	时循环两个或更多的序列，可以使用 zip() 整体打包:

    Python的List功能已经足够完成队列的功能, 可以用 append() 来向队尾添加元素, 可以用类似数组的方式来获取队首元素, 可以用 pop(0) 来弹出队首元素. 但是List用来完成队列功能其实是低效率的, 因为List在队首使用 pop(0) 和 insert() 都是效率比较低的, Python官方建议使用collection.deque来高效的完成队列任务.

    from collections import deque 
    queue = deque(["Eric", "John", "Michael"]) 
    queue.append("Terry")           # Terry 入队 
    queue.append("Graham")          # Graham 入队 
    queue.popleft()                 # 队首元素出队 #输出: 'Eric' 
    queue.popleft()                 # 队首元素出队 #输出: 'John'
    queue                         # 队列中剩下的元素 #输出: deque(['Michael', 'Terry', 'Graham'])

    列表生成式

    Python内置的非常简单却强大的可以用来创建list的生成式。

    >>> list(range(1,21))
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
    >>> L = []
    >>> for x in range(1,11):
    ...     L.append(x*x)
    >>> L
    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
    >>> [x * x  for x in range(1,11)]    #一行的高级写法
    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
    >>> [x * x for x in range(1,11) if x %2 == 0]   #加上if判断，筛选出偶数的平方
    [4, 16, 36, 64, 100]
    >>> [(x,y) for x in [1,2,3] for y in [3,1,4] if x != y]
    [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

    1.4、Tuple（元组）

    元组（tuple）与列表类似，不同之处在于元组的元素不能修改，所以没有增删改操作。元组写在小括号(())里，元素之间用逗号隔开。

    #元组是不可变的，所以初始化后元组内的元素不可改变。

    虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

1 2 3 4

t = tuple() # 构造一个空元组 t = () 也是构造一个空元组 t = (1,) 初始化一个元素的元组，一个元素必须要加逗号 t = (1, 2, 3) # 初始化三个元素的元组

    注意：

    1、与字符串一样，元组的元素不能修改。

    2、元组也可以被索引和切片，方法一样。

    3、注意构造包含0或1个元素的元组的特殊语法规则。

    4、元组也可以使用+操作符进行拼接。

    string、list和tuple都属于sequence（序列）。

    1.5、Sets（集合）

       集合（set）是一个无序不重复元素的序列。

        基本功能是进行成员关系测试和删除重复元素。

        可以使用大括号({})或者 set()函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

     s = set() # 用set函数定义空集合

     s = {}  ！！！这是字典

    1.6、Dictionary（字典）

        列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

       字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。

       键(key)必须使用不可变类型。

       在同一个字典中，键(key)必须是唯一的。

      注意：

    1、字典是一种映射类型，它的元素是键值对。

    2、字典的关键字必须为不可变类型，且不能重复。

    3、创建空字典使用 { }。

    常用字典常量和操作

    

   D = {}
   D = {'spam':2, 'tol':{'ham':1}}             # 嵌套字典
   D = dict.fromkeys(['s', 'd'], 8)            # {'d': 8, 's': 8}
   D = dict(name = 'tom', age = 12)            # {'age': 12, 'name': 'tom'}
   D = dict([('name', 'tom'), ('age', 12)])      # {'age': 12, 'name': 'tom'}
   D = dict(zip(['name', 'age'], ['tom', 12]))    # {'age': 12, 'name': 'tom'}
   D.keys()    D.values()    D.items()       # 字典键、值以及键值对
   D.get(key, default)                   # get函数,指定键的值
   D.update(D_other)              # 合并字典，如果存在相同的键值，D_other的数据会覆盖掉D的数据
   D.pop(key, [D])              # 删除字典中键值为key的项，返回键值为key的值，如果不存在，返回默认值D，否则异常
   D.popitem()                  # pop字典中的一项（一个键值对）
   D.setdefault(k[, d])          # 设置D中某一项的默认值。如果k存在，则返回D[k]，否则设置D[k]=d，同时返回D[k]。
   del D                    # 删除字典
   del D['key']                # 删除字典的某一项
   if key in D:   if key not in D:            # 测试字典键是否存在
   # 字典注意事项：（1）对新索引赋值会添加一项（2）字典键不一定非得是字符串，也可以为任何的不可变对象




一些写法：
{x:x**2 for x in (2,4,6)}	{2: 4, 4: 16, 6: 36}
{k:8 for k in ['s','d']}	{'s': 8, 'd': 8}
{k:v for (k,v) in zip(['name','age'],['tom',12])}	{'age': 12, 'name': 'tom'}
dict(sape=4139, guido=4127, jack=4098)	{'jack': 4098, 'guido': 4127, 'sape': 4139}
字典遍历：
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'} >>> for k, v in knights.items(): ...     print(k, v)	在字典中循环时，关键字和对应的值可以使用 items() 方法同时解读出来:
import collections  | collections.OrderedDict()	这个模块可以记录字典的输入顺序，遍历按输入顺序输出。

---

      附：

• • 迭代：如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）。

  • Python中的索引，从前往后，索引是从0开始，从后往前，索引是从-1开始。

  • 如果索引超出范围，将引发IndexError异常。

• • 
    

---

  2.数据类型转换

函数	描述
int(x [,base])	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为Unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

关键字：