精华内容
下载资源
问答
  • 常见数据类型运算1 变量命名规范'''只能以字母,数字,下划线组成,不能以数字开头。命名时 避免与系统关键字重复,关键字:['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', '...

    常见数据类型和运算

    1 变量的命名规范

    '''只能以字母,数字,下划线组成,不能以数字开头。命名时 避免与系统关键字重复,关键字:['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']长变量名建议使用下划线组成在一起,如:name_of_owen多个单词的简写建议全用大写,ege; URL | HTTP'''

    2 常见的数据数据类型

    整形 int

    py3中所有整形都用int来表示 py2中长整形用long类型存储

    浮点型 float

    用来存储小数的

    salary=888888.0123456789

    # 可以通过格式化方式来绝对输出格式

    # %.6f % salary

    # 1)%f对浮点型数据进行占位

    # 2).后的数据数字表示小数精度

    # 3).前的数据是输出的长度,小于等于要输出的数据长度不起作用,超出就采用规定的最大长度

    # 注:%015.6f:右对齐,左侧不足拿0填充, %-15.6f: 左对齐输出

    print('%015.6f' % salary)

    # 了了解

    # 可以将格式化的结果进行保存,以便之后再次使用

    info = '%015.6f' % salary

    print(info)

    %s是万能占位符, %是用来连接有占位符的字符串与需要占位的变量,多个变量用()包裹

    info = """信息:name:%sage:%s""" % (name, age)

    print(info)

    布尔 bool

    True 真 数字1也代表

    False 假 None 和 0 都为False

    字符串 str

    单行字符串; " " | ' '

    多行字符串: """ """ | ''' '''

    列表 list

    # 1、定义:变量名 = [多个值,之间用,隔开]

    ls = [3, 1, 2]

    # 2、列表变量名ls访问的是列表整体

    print(ls) # [3, 1, 2]

    # 3、通过索引(index)来访问具体的值,index从0开始编号: ls[index]

    print(ls[0]) # 3

    # 4、ls的嵌套及值的访问

    ls = [[1, 2, 3], [4, 5, 6], [7, 8, [9]]]

    # 访问数字9

    print(ls[2][2][0])

    # 重点:list存放值的方式: eg:[3, 1, 2] => 列表的0号位存放的不是数字3,而是堆区3空间的地址 索引都是从0开始的

    字典 dict

    # 定义:{}是用来定义字典的语法,key是用来描述最终要访问的value值的,key对于开发者来说是已知的

    # 访问:通过 dic[key]来访问key描述的值

    dic = {'key': 'value'}

    元祖 (x,)

    元祖:只读列表,只能查询;儿子不能改,孙子是列表则可以改

    只有一个元素,不加逗号,是原数据类型;否则是元祖类型

    集合 set

    集合:可变的数据类型,里面的元素必须是不可变的数据类型   无序----每次运行结果都不一定一样   不重复----列表去重:先转换为集合,再转换成列表即可

    3 运算符

    算术运算符

    \# + | - | * | / | // | ** | %

    \# 1.字符串和list可以做 + 和 *

    \# 2./非整除,// 为整除

    # 3.**求幂:5 ** 2 => 25

    \# 4.任意数 % n => [0, n-1] 取模(余)的公式

    \# 5.有负数参与的取余:符号跟着 % 后面那个数

    比较运算符

    # == 等于 != 不等于 >= <= > <

    赋值运算符

    # += 依次相加 *= %= //=

    1 链式赋值

    a = b = num

    2 交叉赋值

    x = 10

    y = 20

    x,y = y,x

    print(x,y) # 20 10

    3 解压赋值

    ls = [3, 1, 2]

    a, b, c = ls

    # _是合法的变量名,会接受值,但我们认为_代表该解压位不用接收,用_来接收表示

    _, _, g = ls # g才存放2,其他表示不接受

    逻辑运算符

    # and | or | not

    # 1.and: 左右都成立才成立,有不成立的就不成立

    # 2.or: 左右都不成立才不成立,有成立的就成立

    # 3.ont: 成立则不成立,不成立则成立

    res = 0 and 20 # and前为假,整个式子就可以确定为假了,and后就不需要执行(短路)

    print(res) # 0

    res = 10 or 20 # or前为真,整个式子就可以确定为真了,or后就不需要执行(短路)

    print(res) # 10

    res=0 and 20 ===>0 整数时,and为假时,直接为前面值 res= 20 and 0 ===>20 整数时,and为真时,后面值覆盖前面值 所以结果为20 .

    and优先级大于or

    4 数据类型操作

    1 字符串操作

    1.字符串的索引取值: 字符串[index]

    # 正向取值从0编号,反向取值从-1编号

    res = '12345'

    print(res[0]) # 1

    res = '1,2 ,3, 4, 5'

    print(res[0]) # 1

    res = '1,2 ,3, 4, 5'

    print(res[-1]) # 5

    2.字符串拼接

    ls1 = '1,2345'

    ls2 = 'abcde'

    res = ls1 + ls2

    print(res) # 1,2345abcde

    # 拼接其他类型

    s1 = 10

    s2 = 'abc'

    s3 = True

    #res = s1+s2+s3

    #print(res) # 报错 不是同类型

    res = str(s1) + s2 + str(s3) # 正确 10abcTrue 这种情况只能转化为字符串 不能‘abc’转化为整数类型

    res = '%s%s%s' % (s1, s2, s3) # %s 万能占位符 位置一一对应

    3.字符串长度

    res = '10abcTrue'

    print(len(res)) # 9 字符串长度为9

    print(len(res[0])) # 1

    4 字符串切片:

    取子字符串 [::数字] [start_index:end_index:step] 表示索引从某某开始到某某结束,以多少步长计算

    res = '123456abc'

    print(res[0::]) # 表示从0号位开始到结束 123456abc

    print(res[0:6:]) # 123456 表示从0号位开始到6号位结束 则是 123456

    print(res[3:7:]) # 456a

    print(res[::-1]) # cba654321 # 符号表示倒叙取值

    print(res[::-2]) # ca531 # 倒叙2步取值

    print(res[-1:-6:-1]) # cba65 倒叙 取五位值

    5.成员运算:判断某字符串是否在该字符串中 (in 和 not in)

    res = '123456呵呵'

    ls5 = '呵呵'

    print(ls5 in res) # True

    print(ls5 not in res) # False

    6 字符串循环。涉及for循环

    res = '123456呵呵'

    for i in res:

    print(i) # 1 2 3 4 5 6 呵 呵 打印出来每个都是一行

    字符串重要方法

    # 1.索引(目标字符串的索引位置)

    s1 = '123abc呵呵'

    print(s1.index('b')) # 4 表示b对应的位置是从0到4的位置

    # 2.去留白(默认去两端留白,两端没有空格时也可以去两端指定字符) res.strip()

    res = ' ***anc * 789*** '

    print(res.strip()) # ***anc*789*** 把两端的空格去掉了

    res = ' ***anc * 789*** '

    print(res.strip('*')) # ***anc * 789*** 当两端有空格时,还是只能取空格

    res = '***anc * 789***'

    print(res.strip('*')) # anc * 789 两端无空格的情况下 去掉两端的*字符

    # 3.计算子字符串个数 len(res)

    res = '***anc * 789***'

    print(len(res)) # 15

    # 4.判断字符串是否是正整数 res.isdigit

    res = '12345'

    print(res.isdigit()) # True

    # 判断是否是负数 首先判定首字母是-号,在判断后面是不是正整数

    res = '-12345'

    if res.startswith("-") and res[1::].isdigit(): # 首先判断是否是负数 然后在判断-号后面的数就好 ,所以从1开始

    print('负数')

    # 5.大小写转换 res.lower() 转化为小写 | res.upper() 转为大写

    res = 'aBCdEFf'

    print(res.lower()) # 转化为全小写 abcdeff

    print(res.upper()) # ABCDEFF

    # 补充 res.islower() 判断是不是小写 | res.isupper()判断是不是大写

    print(res.islower()) # False

    print(res.isupper()) # False

    # 6.以某某开头或结尾

    res = '12345wsx345'

    print(res.startswith("123")) # True

    res = 'wsx1234edc789'

    print(res.endswith('78')) # False

    # 7.替换 res.replace('y','x',数字) 表示x将替换y, 数字表示将替换几次

    res = 'egon say he is 逗比,egon egon egon!'

    print(res.replace('egon', 'lxx')) # lxx 替换egon 默认替换所有 lxx say he is 逗比,lxx lxx lxx!

    print(res.replace('egon', 'lxx', 3)) # lxx 替换egon三次 lxx say he is 逗比,lxx lxx egon!

    # 8.格式化 只能格式化掉{}的内容

    s8 = 'name:{},age:{}'

    print(s8.format('owen', 18)) # name:owen,age:18 # 默认按位置去掉空字典

    print('name:{1},age:{0}, height:{1}'.format('Owen', 18)) # name:18,age:Owen, height:18

    # 指定位置 name:{1}指的是被format()里的索引1的位置值18代替 age:{0}指的是被format()后面索引的0位置的owen代替

    print('name:{n},age:{a}, height:{a}'.format(a=18, n="Zero")) # name:Zero,age:18, height:18

    # 指名道姓

    # 其他格式

    s7 = '123wsx'

    print(s7.isalnum()) # True 由字母和数字组成的

    s9 = '1234'

    print(s9.isalnum()) # True 由字母和数字组成的

    s10 = '123qaz' # .isalpha判断是否是字母组成

    print(s10.isalpha()) # False

    # 1. find | rfind:查找子字符串索引,无结果返回-1

    # 2. lstrip:去左留白

    # 3. rstrip:去右留白

    # 4. center | ljust | rjust | zfill:按位填充

    # 语法:center(所占位数, '填充符号')

    # 5. expandtabs:规定\t所占空格数

    # 6. captialize | title | swapcase:首字母大写 | 单词首字母大写 | 大小写反转

    # 7. isdigit | isdecimal | isnumeric:数字判断

    # 8. isalnum | isalpha:是否由字母数字组成 | 由字母组成

    # 9. isidentifier:是否是合法标识符

    # 10. islower | isupper:是否全小 | 大写

    # 11. isspace:是否是空白字符

    # 12. istitle:是否为单词首字母大写格式

    2 列表操作

    列表:

    names = ['a','b','c','d']

    1、追加:names.append()

    >>> names.append('e')

    >>> names

    ['a', 'b', 'c', 'd', 'e']

    2、删除:pop,remove,del

    1)pop()

    如果没有指定下标,则默认会删除最后一个元素

    >>> names.pop()

    'e'

    指定下标时,就会删除下标所对应的元

    >>> names.pop(2)

    'c'

    2)remove()

    >>> names.remove('e')

    >>> names

    ['a', 'b', 'c', 'd']

    3)del

    >>> del names[4]

    >>> names

    ['a', 'b', 'c', 'd']

    3、查找元素所在位置:index()

    >>> names.index('c')

    2

    4、统计元素的次数:count()

    >>> names.append('d')

    >>> names.count('d')

    2

    5、反转:reverse()

    >>> names.reverse()

    >>> names

    ['d', 'c', 'b', 'a']

    6、清空:clear()

    >>> names.clear()

    >>> names

    []

    7、插入:insert()

    >>> names.insert(2,'devilf')

    >>> names

    ['a', 'b', 'devilf', 'c', 'd']

    还有其他的插入方法:

    >>> names[3] = 'lebron'

    >>> names

    ['a', 'b', 'devilf', 'lebron', 'd']

    8、排序:sort()按照ascii码来进行排序

    >>> names.insert(4,'&&')

    >>> names

    ['a', 'b', 'd', 'devilf', '&&', 'lebron']

    >>> names.sort()

    >>> names

    ['&&', 'a', 'b', 'd', 'devilf', 'lebron']

    9、列表拼接:extend()

    >>> names.extend(place)

    >>> names

    ['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

    10、列表切片

    1)列出所有的元素

    >>> names[::]

    ['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

    2)列出最后一个元素,从中间位置开始,列出后面所有的元素

    >>> names[-1]

    'usa'

    >>> a = int(len(names)/2)

    >>> names[a:]

    ['devilf', 'lebron', 'beijing', 'shandong', 'usa']

    11、复制:copy()

    >>> names.copy()

    ['&&', 'a', 'b', 'd', 'devilf', 'lebron', 'beijing', 'shandong', 'usa']

    另外的几种复制的方法:

    >>> info = ['name',['a',100]]

    >>> n1 = copy.copy(info)

    >>> n2 = info[:]

    >>> n3 = list(info)

    在使用copy.copy()时,需要导入copy模块

    这些均是浅copy

    例如:

    >>> info

    ['name', ['a', 100]]

    >>> n1 = info[:]

    >>> n2 = copy.copy(info)

    >>> n1

    ['name', ['a', 100]]

    >>> n1[0] = 'devilf'

    >>> n2[0] = 'lebron'

    >>> n1;n2

    ['devilf', ['a', 100]]

    ['lebron', ['a', 100]]

    >>> n1[1][1] = 80

    >>> n1

    ['devilf', ['a', 80]]

    >>> n2

    ['lebron', ['a', 80]]

    这里可以看到修改n1列表中的值,n2中的值也会跟着改变,这就是浅copy,也就是说,浅copy会复制原列表的内存地址,也就是说,我们修改了n1和n2,就是修改了指向同一内存地址的对象,所以info列表会变化,n1和n2都会变化,例如:

    >>> info

    ['name', ['a', 80]]

    5 字典操作

    字典类型

    容器(集合):存放多个值的变量

    单列容器(系统中的单列容器很多):list | tuple

    双列容器(map):只有dict,存放数据 成对出现,dict存放数据采用 key-value键值对方式

    字典中的key可以为什么类型:key必须为不可变类型

    -- key是取value的唯一依据,key一旦被确定,就需要唯一确定(不能被改变)

    字典中的value可以为什么类型:value可以为任意类型

    -- value是用来存放世间所有存在的数据

    key要确保唯一性,不能重复,值可以重复,并且可以被改变 => 字典为可变类型

    dic = {'a': 10, 1: 20, True: 30, (): 40} # 1和True都是1,key具有唯一性,所以只保留最后一次值 print(dic) # {'a': 10, 1: 30, (): 40}

    字典的创建

    空字典

    d1 = {} d2 = dict()

    用map映射创建字典

    d3 = dict({'a': 1, 'b': 1}) print(d3)

    用关键字赋值方式

    d4 = dict(name='Bob', age=18) # 参数=左侧的名字就是合法的变量名,都会被转化为字符串形式的key print(d4)

    创建有多个key值采用默认值的方式: 默认值不写默认None,也可以自定义

    d5 = {}.fromkeys('abc', 0) print(d5)

    字典的操作

    dic = {'a': 1, 'b': 2} print(dic)

    增:

    字典名["key"] = 值 => key已存在就是修改值,不存在就是新增值

    dic['c'] = 3

    print(dic)

    dic['c'] = 30 print(dic)

    查:字典名[key]

    print(dic['c']) # 只能查找已有的key,没有崩溃

    有默认值的查询:有key取出对应value,没有返还默认值,默认值可以自定义

    print(dic.get('d', 'http://www.baidu.com'))

    print(dic)

    清空

    dic.clear()

    pop(k)删除指定key的value并返还删除的value

    res = dic.pop('a')

    # 从dic末尾删除,返还(key, value)形成的元组

    res = dic.popitem()

    print(dic, res)

    更新:

    a有值覆盖,c没被新操作,带下来,b为新增,增加并赋值

    dic = {'a': 1, 'c': 2}

    d = {'a': 10, 'b': 20}

    dic.update(d)

    print(dic) # {'a': 10, 'c': 2, 'b': 20}

    带默认值的新增: 新增key,key已有,啥事不干,没有添加key,值就是第二个参数

    dic.setdefault('z', 100)

    print(dic)

    字典的循环

    1.直接循环,就是循环得到key

    # for k in dic:

    # print(k)

    2.循环keys

    # print(dic.keys())

    # for k in dic.keys():

    # print(k)

    3.循环values

    # print(dic.values())

    # for v in dic.values():

    # print(v)

    同时循环key和value (key, value)

    print(dic.items())

    # a, b = (1, 2)

    # print(a, b)

    # for res in dic.items():

    # print(res)

    重点 解压赋值

    for k, v in dic.items(): print(k, v)

    a, ,, b = (1, 2, 3, 4)

    6 元祖操作

    元组:可以理解为不可变的列表

    # 1.值可以为任意类型

    # 2.可以存放多个值 - 可以进行成员运算

    # 3.可以存放重复的值 - 可以计算成员出现的次数

    # 4.有序存储 - 可以通过索引取值,可以切片

    # 常用操作

    # 1.索引取值

    print(t1[1], type(t1[1]))

    print(t1[-3])

    # 2.运算(拼接)

    print((1, 2) + (2, 3))

    # 3.长度

    print(len(t1))

    # 4.切片

    print((2, 1, 3)[::-1])

    # 5.成员运算

    print(True in t1)

    print(False in t1) # False == 0, t1中如果有0或False,该结果都是True

    # 6.for循环

    for obj in t1:

    print(obj, end=" ")

    print()

    # 方法

    print(t1.count(0)) # 对象0在元组中出现的次数

    print(t1.index(123, 4, len(t1))) # 对象0在区间4~末尾第一次出现的索引

    7 集合操作

    集合类型

    # 空集合:不能用{},因为用来标示空字典

    s = set()

    print(s, type(s))

    # 概念:

    # 1.set为可变类型 - 可增可删

    # 2.set为去重存储 - set中不能存放重复数据

    # 3.set为无序存储 - 不能索引取值

    # 4.set为单列容器 - 没有取值的key

    # 总结:set不能取值

    # 增

    s.add('1')

    s.add('2')

    s.add('1')

    print(s)

    s.update({'2', '3'})

    print(s)

    # 删

    # res = s.pop()

    # print(res)

    # s.remove('1')

    # print(s)

    s.clear()

    print(s)

    # set运算

    # 交集:两个都有 &

    py = {'a', 'b', 'c', 'egon'}

    lx = {'x', 'y', 'z', 'egon'}

    print(py & lx)

    print(py.intersection(lx))

    # 合集:两个的合体 |

    print(py | lx)

    print(py.union(lx))

    # 对称交集:抛出共有的办法的合体 ^

    print(py ^ lx)

    print(py.symmetric_difference(lx))

    # 差集:独有的

    print(py - lx)

    print(py.difference(lx))

    # 比较:前提一定是包含关系

    s1 = {'1', '2'}

    s2 = {'2'}

    print(s1 < s2)

    5 深浅拷贝

    值拷贝 :ls = [1,2,3] res = ls 则print(res)就是[1,2,3]

    浅拷贝 :ls.copy()

    深拷贝:ls3 = deepcopy(ls) # 新开辟列表空间,ls列表中的不可变类型的地址直接拿过来,但是可变类型的地址一定重新开辟空间 # ls内部的所有类型的值发生改变,ls3都不会随之变化

    可变对象 指 可以在原处修改,而不用创建新的对象(包括列表,字典,集合); 不可变对象指 不支持在原处修改,只能通过表达式创建新的对象,然后把结果分配给变量(包括 数字,字符串,元组)。

    6 数据类型的转换

    数字类型之间的转化

    主要关注两个用法

    join 组合 用于 列表转为字符串

    split 拆分 字符串和列表都可以使用

    字典与其他之间的转化 间接转化

    1 转化为数字类型

    res = int('10') # 字符串转化为数字

    print(res)

    res = int('-3')

    print(res)

    res = float('.15')

    print(res) # 0.15

    res = float('-.15')

    print(res) # -015

    res = float('-3.15')

    print(res) # -3.15

    2:字符串与列表相互转换 (重要)

    s = 'abc123呵呵'

    print(list(s)) # ['a', 'b', 'c', '1', '2', '3', '呵', '呵'] 字符串转列表

    ls = ['a', 'b', 'c', '1', '2', '3', '呵', '呵']

    n_s = '.'.join(ls) # 列表转字符串 ''.join()

    print(n_s) # a.b.c.1.2.3.呵.呵

    #

    s = 'abc123呵呵'

    print(list(s)) # ['a', 'b', 'c', '1', '2', '3', '呵', '呵']

    ls = ['a', 'b', 'c', '1', '2', '3', '呵', '呵']

    n_s = ''.join(ls) # 这是没有点号的显示

    print(n_s) # abc123呵呵 这是没有点号的显示,点好也可以转换为其他

    #

    s1 = 'a b c 1 2 3 呵 呵'

    res = s1.split() # 把字符串转化为列表 默认按空格拆

    print(res) # ['a', 'b', 'c', '1', '2', '3', '呵', '呵']

    s2 = 'ie=UTF-8&wd=你好帅'

    res = s2.split('&') # 字符串改列表

    print(res) # ['ie=UTF-8', 'wd=你好帅'] split默认按空格来隔开,s2.split('&')则是把&两边分开为列表,中间可以是其他的,

    # 比如- 或8,只要是在s2里就行

    ls2 = ['ie=UTF-8', 'wd=你好帅']

    n_s2 = '@'.join(ls2)

    print(n_s2) # ie=UTF-8@wd=你好帅 ''.join() 中''可以加其他的 比如@ 或4 则列表组合中间多一个其他

    # 4:需求:"ie=UTF-8&wd=你好帅" => [('ie', 'UTF-8'), ('wd', '你好帅')]

    res = []

    s4 = "ie=UTF-8&wd=你好帅"

    ls4 = s4.split('&') # ['ie=UTF-8', 'wd=你好帅']

    for ele in ls4: # v = ie=UTF-8 | wd=你好帅 for 循环把每个值取出来

    k, v = ele.split('=') # k: ie v: UTF-8 赋值 k ,v = ele.split('=')

    res.append((k, v))

    print(res)

    # 5.需求:"ie=UTF-8&wd=你好帅" => {'ie': 'UTF-8', 'wd': '你好帅'}

    res = {}

    s5 = "ie=UTF-8&wd=你好帅"

    ls5 = s5.split('&') # ['ie=UTF-8', 'wd=你好帅']

    for ele in ls5:

    k, v = ele.split('=') # 去掉 =

    res[k] = v # 添加字典的模式 res[k] = v 如果字典中res,有k这个,则把值v赋值给k,如果没有,则在字典中添加k:v

    print(res) # {'ie': 'UTF-8', 'wd': '你好帅'}

    # 6.需求:[('ie', 'UTF-8'), ('wd', '你好帅')] => {'ie': 'UTF-8', 'wd': '你好帅'}

    res = {} # 建立新的空字典

    ls6 = [('ie', 'UTF-8'), ('wd', '你好帅')]

    for k, v in ls6:

    res[k] = v

    print(res)

    3.list与tuple、set直接相互转化 - 直接 类型()

    # 8.需求:将汉字转化为数字

    # 将 壹、贰、叁、肆、伍、陆、柒、捌、玖、拾、佰、仟

    # 转化为 1、2、3、4、5、6、7、8、9、10、100、100

    # 作业:壹仟捌佰玖拾叁 => 1893

    num_map = {

    '壹': 1,

    '贰': 2,

    '仟': 1000

    }

    ls8 = ['贰', '壹', '仟']

    res = []

    for v in ls8:

    num = num_map[v] # 通过key去映射表拿到对应的值,完成 '贰' => 2

    res.append(num)

    print(res)

    展开全文
  • 在使用Tensor时,我们首先要掌握如何使用Tensor来定义不同数据类型的变量。Tensor时张量的英文,表示多维矩阵,和numpy对应,PyTorch中的Tensor可以和numpy的ndarray相互转换,唯一不同的是PyTorch可以在GPU上运行,...

    在使用Tensor时,我们首先要掌握如何使用Tensor来定义不同数据类型的变量。Tensor时张量的英文,表示多维矩阵,和numpy对应,PyTorch中的Tensor可以和numpy的ndarray相互转换,唯一不同的是PyTorch可以在GPU上运行,而numpy的ndarray只能在cpu上运行。

    常用的不同数据类型的Tensor,有32位的浮点型torch.FloatTensor,   64位浮点型 torch.DoubleTensor,   16位整形torch.ShortTensor,    32位整形torch.IntTensor和64位整形torch.LongTensor

    一:Tensor的数据类型

    1  torch.FloatTensor:用于生成数据类型为浮点型的Tensor,传递给torch.FloatTensor的参数可以是一个列表,也可以是一个维度值

    fece2b27fd8051fb7f8b44963972efb0.png

    2:torch.IntTensor:用于生成数据类型为整形的Tensor,传递给torch.IntTensor的参数可以是一个列表,也可以是一个维度值

    edbe93a8bc117b848e5c196f1eea5aa0.png

    3:torch.rand:用于生成数据类型为浮点型且维度指定的随机Tensor,和在NumPy中使用的numpy.rand生成随机数的方法类似,随机生成的浮点数据在0-1区间均匀分布

    b1994057a7cb029767272bbb3c7e6240.png

    4:torch.randn:用于生成数据类型为浮点型且维度指定的随机Tensor,和在NumPy中使用numpy.randn生成随机数的方法类似,随机生成的浮点数的取值满足均值为0,方差为1的正态分布

    78e00cf595eb24d4c1be9cc12ed6ade9.png

    5:torch.range:用于生成数据类型为浮点型且自定义起始范围和结束范围的Tensor,所以传递给torch.range的参数有三个,分别是范围的起始值,范围的结束值和步长,其中,步长用于指定从起始值到结束值得每步得数据间隔

    二:Tensor的运算

    通过对Tensor数据类型的变量进行运算,来组合一些简单或者复杂的算法,常用的Tensor运算如下。

    1.torch.abs:将参数传递到torch.abs后返回输入参数的绝对值作为输出,输入参数必须是一个Tensor数据类型的变量。

    2.torch.add:将参数传递到torch.add后返回输入参数的求和结果作为输出,输入参数可以全部是Tensor数据类型的变量,也可以一个是Tensor数据类型的变量,另一个是标量。

    5b5868f0b6aa6c10ee1b677704d37d6b.png

    3.torch.clamp:对输入参数按照自定义的范围进行裁剪,最后将参数裁剪的结果作为输出。所以输入参数一共有三个,分别是需要进行裁剪的一共三个,分别是需要进行裁剪的Tensor数据类型的变量,裁剪的上边界,下边界。过程是,让变量的每个元素分别和上下边界比较,如果小于下边界,该元素就被重写下边界的值,如果大于上边界,该元素就被重写上边界的值。

    6e43721979982a0d8386cdee510a9cfa.png

    4.torch.div:将参数传递到torch.div后返回输入参数的求商结果作为输出,同样,参与运算的参数可以全部是Tensor数据类型的变量,也可以是Tensor数据类型的变量和标量的组合

    3c7cf2b4b5e211363ebacbc3780eda4a.png

    5.torch.mul:将参数传递到torch.mul后返回输入参数求积的结果作为输出,参与运算的参数可以全部是Tensor数据类型的变量,

    也可以是Tensor数据类型的变量和标量的组合

    6.torch.pow:将参数传递到torch.pow后返回输入参数的求幂结果作为输出,参与运算的参数可以全部是Tensor数据类型的变量,

    也可以是Tensor数据类型的变量和标量的组合

    就是a的b次方

    5bc374e4745dbbbb61188408e2f0df88.png

    7.torch.mm:将参数传递到torch.mm后返回输入参数的求积结果作为输出,不过这个求积结果的方式和之前的torch.mul运算方式不一样,toch.mm运用矩阵之间的乘法法则进行计算,所以被传入的参数会被当作矩阵进行处理,参数的维度自然也要满足矩阵乘法的前提条件,即前一个矩阵的行数必须和后一个矩阵的列数相等,否则不能计算。

    8.torch.mv:将参数传递到torch.mv后返回输入参数的求积结果作为输出,torch.mv运用矩阵与向量之间的乘法规则进行计算,被传入的第一个参数代表矩阵,第二个参数代表向量,顺序不能颠倒

    09be9e3528034c0baaece6cdc7247765.png

    到此这篇关于PyTorch中Tensor的数据类型和运算的使用的文章就介绍到这了,更多相关PyTorch Tensor数据类型和运算内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

    展开全文
  • 此节来自于《Python学习手册第四版》第二部分一、Python对象类型(第4章)1、 Python可以分解成模块、语句、表达式以及对象:1、程序由模块构成;...上图Python内置对象类型,不过并完整,因为Pyt...

    此节来自于《Python学习手册第四版》第二部分

    一、Python对象类型(第4章)

    1、 Python可以分解成模块、语句、表达式以及对象:1、程序由模块构成;2、模块包含语句;3、语句包含表达式;4、表达式建立并处理对象。Python是动态类型,就和matlab一样无需提前声明,但是也是强类型语言,因为一旦有了对象那么他的操作集合也就确定了。

    上图Python的内置对象类型,不过并不完整,因为Python处理的每样东西都是对象,在后面会介绍像函数、模块和类这样的编程单元在Python中也是对象,他们由def、class、import、lambda这样的语句和表达式创建,而且可以自由的在脚本之间传递,存储在其他对象中。所以上图叫做核心数据类型。

    2、import 命令用来导入模块,比如>>>import math 。

    3、在核心类型中,数字、字符串和元组是不可变的;列表和字典不是这样(它们可以完全自由的改变)。

    4、可用作多种类型的通用型操作都是以内置函数或表达式的形式出现的:len(x),X[0],但是类型的特定的操作都是以方法调用的形式出现的:aString.upper()。

    5、>>>dir(S)可以返回一个列表,其中都是该对象的所有属性,由于方法是函数属性,所以他们也会出现在列表中。一般来说,这个列表中会有一些双下划线开头和结尾的变量名,他们是用来表示Python实现细节的命名模式,而没有下划线的属性就是字符串对象能够调用的方法。

    6、help(S.replace) dir函数是简单的给出了方法的名称,要查询它们是做什么的,就用这样的help函数。

    7、在python中单引号和双引号意思一样,都可以用来表示字符串,而且三个引号的中间可以包括多行字符串常量:“”“ 第一行;第二行;第三行“”“。

    8、>>>import  re   >>>match = re.match('hello[\t]*(.*)world',"hello     python world")  >>>match.group(1);这是第98页模式匹配例子。以此作记录而已。

    9、在字典中进行索引是用【】的不是用()的;【】在序列中都可以使用。

    10、在c这样的底层语言中,需要自己手动释放所有对象空间,在Python中,当最后一次引用对象(比如将这个变量用其他的值进行赋值),这个对象的内存空间就会被自动清理掉;

    11、for var in  dataset: your operation ...   用户定义一个循环变量var,然后将其与dataset中的进行对比,然后进行操作结果。for是用来遍历一个序列的。

    12、Python的迭代协议:a、表示内存中物理存储的序列,或是在一个迭代操作情况下每次产生一个元素对象,如果一个对象在响应neixt之前先用一个对象对iter内置函数做出响应,那么属于后一种,比如for key in  sort(字典):

    13、还可以比如squares = 【x ××2  for x in 【1,2,3,4】】。这样的列表解析表达式。

    14、上述涉及到的in 是一种表达式,比如>>>‘f’ in D  返回 false  这就说明不在里面。

    15、元组看上去和列表一样,元组是序列,不过它具有不可变性,和字符串类似。它编写在圆括号中而不是方括号中,支持任意类型、任意嵌套以及常见的序列操作。Python3.0 两个元组专用调用方法:>>>T.index(4);>>>T.count(4)。

    16、集合是最近增加到这门语言中的类型,它是唯一的不可变的对象的无序集合,通过内置set函数创建,或者使用3.0的新的集合常量和表达式创建,支持一般的数学几何操作。

    17、python提供的新的数值类型:十进制数和分数,用来解决浮点数学的局限性和内在的不精确性。>>>import decimal ;>>>from  fractions import Fraction

    18、type()在3.0中,返回的就是类型class 而不是type,有三种方法可以用来测试,在书113页。

    19、python支持自定义的类,也就是面向对象的编程,其中类内函数中的参数“self”对象是具有this的功能的。

    20、数字、字符串和元组不可变;字符串、列表和元组是序列,有索引,合并和分片。

    二、数字(第5章 )

    在Python中,数字并不是一个真正的对象类型,而是一组类似类型的分类。Python数字类型的完整工具包括:1、整数和浮点数;2、复数;3、固定精度的十进制数;4、有理分数;5、集合;6、布尔类型;7、无穷的整数精度;8、各种数字内置函数和模块。

    1、内置函数:hex(I)、oct(I)、bin(I)把一个整数转换为这3种进制表示的字符串,int(str,base)把一个运行时字符串转换成一个整数。

    2、可以通过内置函数complex(real,imag)来创建复数。

    3、下面的是内置的数学操作和扩展:

    4、数字也是有很多特定于类型的方法,比如浮点数有一个as_integer_ratio,这对于分数数字类型也很有用;还有is_integer方法可以测试数字是否是一个整数;还有Python3.1将要发布的bit_length用来得到对象的值所必须的位数。

    5、下面的是数字的表达式操作符:

    ps:(...)用于表示元组和表达式,以及生成器表达式,后者是产生所需结果的列表解析的一种形式,而不是构建一个最终的列表,有时候圆括号会省略。

    【...】用于表示列表常量或列表解析表达式,后者执行隐性循环,把表达式的结果收集到新的列表中。

    yield和三元选择表达式在2.5之后采用,前者返回生成器中的send(...)参数,后者是一个多行if语句的缩写形式。如果yield不是单独的位于一条赋值语句的右边的话,需要用圆括号。

    6、操作符的优先级:在表5-2中,操作符越靠后,优先级越高;如果在同一行中,则从左到右进行结合(幂运算是从右到左结合的,比较运算是从左到右结合的)。

    7、python当遇到例如40+3.14的时候,也会和cpp一样进行不同的类型升级再进行运算。整数

    8、str和repr显示格式:例如>>>num = 1/3 ; >>>repr(num) ;结果是‘0.333333..1’;而>>>str(num);结果是‘0.333333’(后者是友好型)。这两个函数都是将任意对象转换成字符串表示,repr(即默认的交互模式回显)产生的结果看起来像代码;str(也就是打印语句)将有更好的用户格式。

    9、//操作符通常叫做截断除法,更准确的应该叫做floor出发,是将结果向下截断到它的下层,即向下舍去>>>import math;>>>math.floor(2.5);2(如果是-2.5 结果是-3)>>>math.trunc(2.5);2(如果是-2.5结果是-2);也就是floor是数轴上往下,而trunc是数轴上往0靠拢。另:试试round()

    10、接第1条,eval函数可以将字符串作为python的代码,不过更慢:>>>eval('64'),eval('0o100'),eval('0x40'),eval('0b10000000');结果(64,64,64,64);不过还能用字符串格式化方法调用表达式:>>>'{0:0},{1:x},(2:b)'.format(64,64,64);结果是‘100,40,1000000’;或者>>>'%0,%x,%X' %(64,255,255);结果是‘100,ff,FF’

    11、(256).bit_length 等于len(bin(256))-2=9

    12、random是模块,math是模块

    13、小数数字,是通过导入的模块调用函数后创建的,不是通过运行常量表达式创建的。功能上说,小数对象就像浮点数,不过他们有固定的位数和小数点,所以小数是有固定的精度的浮点值。;而且浮点数缺乏精确性,因为它是通过存储空间来进行无线逼近的,比如>>>0.1+0.1+0.1-0.3 结果不是0,而是无限接近0的值,就算使用友好的打印格式,还是因为浮点数的精度自身缺陷没办法,使用小数就能改正:>>>from  decimal import Decimal;>>>Decimal('0.1')+Decimal('0.1')+Decimal('0.1')-Decimal('0.3')

    结果就是Decimal('0.0');通过Decima的构造函数创建一个小数对象,并传入一个字符串,其中是我们希望结果显示的小数位数,如果有不同位数,那么自动升级最多的那个。在3.1版本中可以使用decima.Decimal.from_float(1.25)这样来转换。或者使用decimal.getcontext().prec = 4,来将后续的设置成4位精度。

    14、接13点,可以使用小数上下文管理器语句来重新设定临时的进度,语句推出后,精度又被还原:>>>with decimal.localcontext() as ctx: ...   ctx.prec = 2 ...  decimal.Decimal('1.00')/decimal.Decimal('3.00');

    15、分数和小数一样用来解决浮点数的一些精度问题的。在python中它明确的保留了一个分子和一个分母,从而避免浮点数的不精确性和局限性;分数也存在模块中,>>>from fractions import Fraction ;>>>x = Fraction(1,3);并支持普通的数学运算;而且分数还能够自动简化成最简分数。

    16、可以将浮点数对象转换成分数>>>(2.5).as_integer_ration();结果是(5,2);或者>>>f = 2.5 ;>>>z = Fraction(*f.as_integer_ratio())(这里的×是将一个元组扩展到单个的参数中);>>>Fraction.from_float(1.75);得到的就是Fraction(7,4);int

    17、集合:不管某个元素被添加多少次,它在集合中只会出现一次。set([1,2,3,4])等同于{1,2,3,4};空的集合必须通过内置函数set来创建。通过使用union函数,可以解决,如下图:

    18、集合只能包含不可变的对象类型,所以列表和字典不能嵌入到集合中,元组可以;集合本身是不可改变的,所以不能直接嵌入到其他集合中,如果需要,可以像调用set一样来调用frozenset,不过它创建的是一个不可变集合,该集合不可修改不过可以嵌套到其他集合中。

    19、3.0版本中,引入了一个集合解析构造,类似列表解析的形式,不过不是写在方括号而是花括号中,而且作用于集合而不是列表。集合解析运行一个循环并在每次迭代时收集一个表达式的结果,通过一个循环变量来访问当前的迭代值以用于集合表达式中。结果是通过运行代码创建的一个新的集合。>>>{x ** 2 for x in [1,2,3,4]} 结果就是{16,1,4,9};这里循环部分写在for右边,而集合表达式写在for左边。集合天生的功能可以用来将一些列表过滤掉重复项。

    20、布尔类型:>>>True == 1;True,可是如果>>>True is 1 结果是False

    三、动态类型(第6章)

    犹如matlab一样,无需事先声明变量,直接拿来用即可,从变量到对象的连接称作引用。也就是说,引用是一种关系,以内存中的指针形式实现。一旦变量被使用(即被引用),python自动跟随这个变量到对象的连接。每个对象都有2个标准的头部信息:一个类型标志符标识这个对象的类型;一个引用计数器,表示是否可以回收。这是因为类型是属于对象的,而不属于变量名,所以可以一直换,变量没有类型,所以实际上并没有改变变量a的类型,只是让变量引用了不同的类型的对象而已。

    1、在内部,python在每个对象中保持一个计数器,计数器记录当前指向该对象的引用的数目,一旦计数器设置成0,这个对象的内存空间就会被自动回收,当变量被赋值给新的对象的时候,前一个对象的计数器就会被设置成0,而引发回收操作。ps:由于引用的实现是靠指针的,所以当情况1:一个对象引用自己;情况2:一个对象引用了另一个引用自己的对象。这两种情况下对象的引用计数器不会清零,要特别注意。

    2、a = 3;b = a;a = a+3;结果来说并不会改变b的副作用。事实上,也没法改变,因为整数本身就是不可变的。在python中,变量总是一个指向对象的指针,而不是可改变的内存区域的标签:给一个变量赋一个新值,不是替换原始的对象,而是让变量去引用完全不同的一个对象。

    3、L==M;和L is M ;前者是测试两个被引用的对象是否有相同的值,而后者是检查是否同一性,如果两个变量名都精确的指向同一个对象,那么就是True的,所以后者更严格。其实is  是比较两个引用的指针。

    4、按照3的观点:x=42;y=42;x==y 和x is y ,;前者是没问题,可是按道理来说这是两个不同的常量表达式,不过因为python系统的针对小的整数和字符串被缓存并复用了,所以is 让我们知道这两个引用的是同一个对象。不过可以使用sys模块中的getrefcount函数来返回对象的引用次数。

    四、字符串(第7章)

    一个有序的字符的集合,与c不同的是python没有char类型,只有单个字符的字符串。下表是常见的字符串常量和操作,空字符串表示为一对引号(单引号,双引号无所谓)

    1、python通过标准库re模块支持基于模式的字符串处理(第四章),还有xml解析器。在3.0中,有3中字符串类型:str用于unicode文本(ascii或其他),bytes用于二进制数据(包括编码的文本),bytearray是bytes的一种可变的变体。(这里对应的2.6版本略,p169)。

    2、python也支持在任意的表达式中合并相邻的字符串常量:t = ‘wara’ “fawea”;结果就是t = ‘warafawea‘;len(s)用来返回字符串中有多少个字节,因为有时候使用\n 或者\t 等来做转义字符:

    3、在python中,零(空)字符不会像c语言那样去结束一个字符串,相反,python在内存中保持了整个字符串的长度和文本。而且python没有字符会结束一个字符串。python会以16进制显示非打印的字符。

    4、raw字符串抑制转义:myfile = open(‘C:\new\text.dat’,‘w’);这个语句中\n和\t就会被认为是转义字符而无法真正的打开。如果使用myfile = open(r‘C:\new\text.dat’,‘w’);也就是在前面加一个r用来关闭这个字符串的转义机制,不过该方法不能能以'...\'单个反斜杠结束,必须在最后手动添加一个'...\\'这样结束;或者在这种有歧义的地方使用\\两个斜杠来保证会有一个斜杠输出;而且python会自动在windows和unix中使用正斜杠表示字符串路径,比如"C:/new/text.data"。

    5、三重引号编写多行字符串块,略

    6、in是用来测试成员关系的,这里很像str.find(),它返回一个布尔结果,而不是子字符串的位置。>>> 'k'   in  'kl'  ;返回的是True.

    7、字符串支持负偏移,s = 'spam'; s[0],s[-2],s[1:3],s[1:],s[:-1]。不过记得这里的偏移量是【)这样的左闭右开的范围。不过X【I:J:K】这里和matlab不一样,这里的间隔是第三个K,取范围为【I,J) 内部的值。

    8、分片等同于用一个分片对象进行索引:ps:为了去掉换行字符,可以使用line.restrip方法(暂时没搞懂,因为在3.0中str.rstrip(),是将最后的空字符删除而已,不过可以使用help(str.rstrip)来看看),这个方法会留下没有换行字符那行的最后一个字符。

    9、字符串-数字的简单转换>>>int("42"),str(42);结果是(42,‘42’);>>>repr(42);结果是‘42’。repr返回的对象可以作为代码的字符串,可以重新创建对象。对于字符串来说,如果是使用print语句显示,结果需要用引号括起来>>>print(str('spam'),repr('spam'));结果是(‘spam’,“ ‘ spam ’   ”)(注意引号的个数)

    10、字符串代码转换:ord函数将单个字符转换成ascii,而chr函数将ascii转换成字符。ord('a') 结果是65,而chr(65)结果是‘a'。还有int('1101',2)可以将二进制转换成十进制。

    11、修改字符串可以有两种方法:s = s[:4]+'Burger' + s[-1];这也就是用分片的方法来将需要的部分提取出来;或者s = s.replace('pl','pamal');这是将该字符串中原有的pl换成pamal部分。

    12、字符串格式化:

    13、在3.0和2.6中引入的一种叫做bytearray的新字符串类型,它是可以修改的,因为它不是真正的字符串,而是较小的,8位整数的序列。不过它支持和常规字符串相同的大多数操作,并且显示的时候打印为ascii字符,而且为必须频繁修改的大量文本提供了另一个选项。在36章中有更详细的说明。

    14、除了表达式运算符外,字符串还提供一系列方法来实现更复杂的文本处理任务,方法就是与特点对象关联的函数,它们是附属于对象的属性,而属性也就是可调用的函数罢了,在python中,表达式和内置函数可能在不同范围的类型有效,但是方法通常特定与对象类型。更详细的说:函数也就是代码包,方法调用的时候进行两次操作(一次获取属性,一次函数调用):object.attribute表达式理解为“读取object对象的属性attribute的值”。方法调用表达式对象,方法(参数)从左至右运行,也就是说先读取对象方法,然后调用它,传递参数。如果一个方法计算出一个结果,它将会作为整个方法调用表达式的结果被返回。

    s是一个字符串对象,可选的参数包含在方括号中,这个表中的字符串方法实现了分割和连接、大小写转换、内容测试、子字符串查找和替换这样的高级操作。

    15、如果想替换一个固定长度的字符串,可以先使用find搜索,然后使用分片的方法。where = s.find('spam'),如果没找到返回-1,而且s.replace('spam','eggs',1),意思是替换一次。不过如果是一个超长的字符串,需要这样不断的创建新的字符串来达到替换的目的,有些吃力,可以转换成列表: L = list(S)。在多次修改之后,如果想变回字符串:S = ‘’.join(L);该语句的意思是用‘’(这里是空分隔符,也可以‘**’,这样的分隔符)来将参数链接起来。

    16、文本解析:通过分片将数据从原始字符串中分出来;如果你所需要的数据组件没有固定的偏移,而是被分隔符分开,那么可以使用split提取出来。比如:line.split(',')是以逗号分隔符分开。

    17、实际应用的一些常见的字符串方法:

    18、相比较来说调用对象方法:X.method(argument)比通过string模块调用相同的运算要好:string.method(X,argument)。(需要事先导入string模块)

    19、字符串格式化有两种形式:a、字符串格式化表达式;b、字符串格式化方法调用。a、%操作符为编写多字符串替换提供了一种简洁的方法,格式化字符串:在%操作符的左侧放置一个需要格式化的字符串,这个字符串带有一个或多个嵌入的转换目标,都以%开头;在%操作符右侧放置一个(或多个,嵌入到元组)的对象,这些对象将会插入到左侧想要转换的目标位置上:

    20、更高级的字符串格式化表达式代码:在这其中,表达式左侧的转换目标支持多种转换操作,语法如下:%[(name)] [flags] [width] [.precision] typecode。

    其中typecode就是上表的编码,其中的flags可以是左对齐(-),正负号(+)和补零(0)的标志位。

    如果在运行的时候才知道大小,可以在格式化字符串中用一个×来指定通过计算得到的width和precision,从而使得它们的值是从%右边的输出中的下一项得到的:

    这里×表示右边的4。

    21、基于字典的字符串格式化:

    ,这个例子中,格式化字符串里(n)和(x)引用了右边字典的键,并提取它们相应的值。这可以用来生成类似html或者xml的程序,上面的语法中的name这里就可以看见:

    这同样可以与内置函数vars配合使用,该函数返回的字典包含了所有在本函数中调用时候存在的变量,当字典用在一个格式化操作的右边时,它会让格式化字符串通过变量名来访问变量(也就是说,通过字典中的键):

    22、在2.6和3.0中新的字符串对象的format方法使用主题字符串作为模板,并且接受任意多个表示将要根据模板替换的值的参数。在主题字符串中,花括号通过位置({1};{food})指出替换目标及要插入的参数。函数和方法的参数都可以使用位置和关键字名称来传递。

    23、格式化调用可以变得更复杂以支持更多高级用途。比如可以指定对象属性和字典键,方括号指定字典键,而点表示位置惑关键字所引用的一项的对象属性:

    上图中【】表示索引,0和1表示format中的位置。第二个例子不是通过位置,而是通过关键字来指定对象。而且在格式化字符串(也就是format左边的字符串)可以指定列表(及其他序列)偏移量以执行索引,不过只有单个的,正的偏移才合法,如果要指定负的偏移惑分片,或者使用任意表达式,需要在格式化字符串自身之外运行表达式:

    24、另一种和%表达式类似的是,在格式化字符串中添加额外的语法来实现更具体的层级。对于格式化方法,在替换目标的标识之后使用一个冒号,后面跟着可以指定字段大小、对齐方式和一个特定类型编码的格式化声明:

    上述语法中:fieldname是指定参数的一个数字惑关键字,后面跟着可选的“.name”或“【index】”成分引用;conversionflag可以是r、s或者a分别是在该值上对repr、str惑ascii内置函数的一次调用;formatspec指定了如何表示该值、包括字段宽度、对齐方式、补零、小数点精度等细节,并以一个可选的数据类型编码结束。冒号后的formatspec组成形式上的描述如下(方括号表示可选的组成,并且不能编写为常量):

    align可能是,=或^,分别表示左对齐、右对齐、一个标记字符后的补充或居中对齐。formatspec也包含嵌套的、只带有{}的格式化字符串,它从参数列表动态的获取值(和格式化表达式中的*很相似)。这里的格式化方法还允许一个“b”类型编码用来以二进制格式显示整数(它等同于使用bin内置函数),允许一个“%”类型编码来显示百分比,并且使用唯一的“d”表示十进制的整数(而不是“i”惑“u”):

    这里的{0:10}意味着一个10字符宽的字段中第一个位置参数,{1:<10}意味着第二个位置参数在一个10字符宽度字段中左对齐,{0.platform:>10}意味着第一个参数的platform属性在10字符宽度的字段中右对齐。

    格式化参数可以在格式化字符串中硬编码,或者通过嵌套的格式化语法从参数列表动态的获取,后者很像是格式化表达式中的星号语法:

    当然2.6和3.0还提供了一种新的内置format函数,可以用来格式化一个单独的项,他是字符串格式化方法的一种更简洁的替代方法,并且大致类似%格式化表达式来格式化一个单独的项:

    从技术上说,内置函数format运行主体对象的__format__方法,对于每个被格式化项目,str.format方法都是内部的,它仍然比最初的%表达式的对等体要冗长。

    25、最初的%表达式无法处理关键字、属性引用、二进制类型代码,尽管%格式化字符串中的字典键引用常常能够达到类似的目标:

    如下代码显示有的时候%表达式往往能够更简单:

    格式化方法拥有%表达式所没有的很多高级功能,不过更复杂的格式化似乎看起来也能从根本上降低复杂性:

    在方法调用中的**数据是特殊的语法,它把键和值的一个字典包装到单个“name=value”关键字参数中,以便可以在格式化字符串中用名字来引用他们:

    加个逗号表示千分隔符。

    26、为什么在很多地方%表达式很简单,但是还是推荐格式化方法:因为a、拥有%表达式所没有的额外功能;b、可以更明确的进行替代值引用;c、考虑从到操作符会有一个更容易记忆的方法名;d、不支持用于单个和多个替代执大小写的不同语法:

    a、额外功能:

    c、使用格式化表达式,单个值可以独自给,多个值必须放入一个元组中:

    格式化方法通过在两种情况下接受通用的函数参数,把这两种情况绑定到一起:

    也许在将来会废弃%表达式而使用format方法。

    五、列表与字典(第8章)

    这两种都支持原处修改,而且支持包含任意种类的对象或者被嵌套:a、任意对象的有序集合;b、通过偏移读取;c、可变长度、易购以及任意嵌套;d、属于可变序列的分类;e、对象引用数组。

    1、map内置函数可以将序列中的各项应用一个函数并把结果收集到一个新的列表中:

    2、sort的简单用法:

    当sort()中参数为空时,默认升序排列。

    3、如果使用L = L.append(X),这样的形式,会让L失去引用,因为该函数调用本身就会修改自己,所以直接写成L.append(X)就好。sort也是一样。而且现在有了内置函数sorted(),会比sort方法更有用,而且可以在排序前加上一个列表解析:

    字典是python中最灵活的内置数据结构类型,如果把列表看作是有序的对象集合,那么可以把字典看成是无序的集合,它们主要差别在于字典是通过键来存取的:a、通过键而不是偏移量来读取;b、任意对象的无序集合;c、可变长、异构、任意嵌套;d、属于可变映射类型;e、对象引用表(采用最优化的散列算法来寻找键),和列表一样,字典存储的是对象引用,而不是对象本身(想象成上面说的变量名就行)。

    4、当键不存在的时候通过get方法能够返回默认值(None或者用户定义的默认值),这是在当键不存在时为了避免missing-key错误而填入默认值的一个简单方法:字典的update类似于合并,不过它会盲目的覆盖相同的键的值。

    5、在字典中for key in D:和for key in D.keys():效果是一样的。

    6、字典用法注意事项:a、序列运算无效;b、对新索引赋值会添加项;c、键不一定总是字符串(任何不可变对象,也是可以的)。

    7、字典可以用于稀疏数据结构:

    这样就只存储了一个三维矩阵中两个有值的位置。

    8、字典中避免missing-key的三种方法:

    9、字典接口需要特别注意,因为Python的DBM接口也是通过键来获取文件的,比如anydbm模块,shelve模块,cgi模块等等。P229

    10、创建字典的方法:

    上图中第一种适合事先拼出整个字典,第二个可以动态创建字典,第三个只能用键做字符串,第三种可以在程序运行是将键和值逐步建成序列。而且如表8.2所示,最后一种可以与zip函数一起使用,将程序运行时动态获取的键和值的不同列表合并在一起。

    11、如果想将所有的键的值初始化成一样的:

    12、在3.0中字典的变化:a、支持新的字典解析表达式,这是列表和集合解析的“近亲”;b、对于D.key、D.values、D.items方法,返回可迭代的视图,而不是列表;c、因为b ,需要新的编码方式通过排序键来遍历;d、不再直接支持相对大小的比较--需要手动比较;e、不再有D.has_key方法,相反,使用in 成员关系测试。

    13、字典解析只能在3.0中使用,这是上面之外的第五种方法,不过现插入一个在2.6和3.0中的动态初始化一个字典的标准方式:将其键和值对应起来并把结果传递给dict调用,如果不能在代码中预计键和值的集合,总是可以将他们构建为列表然后在对应起来:

    而在3.0中可以使用字典解析表达式:

    更多例子:

    14、在3.0中字典的keys、values和items都返回视图对象;而在2.6中,它们返回实际的结果列表。视图对象是可迭代的,这就意味着对象每次产生一个结果项,而不是在内存中立即产生结果列表,除了可以迭代,字典试图还保持了字典成分的最初顺序,另一方面,它们不是列表,并且不支持像索引和列表sort方法的操作。想要应用列表操作或者显示它们的值,需要通过内置函数list来运行这三个方法的结果:

    >>>D = dict(a = 1,b=2,c=3);

    >>>K = D.keys();   >>> list(k)

    >>>V = D.values();  >>>list(V)

    >>>list(D.items());  >>>list(K)[0]

    15、在3.0中keys方法返回的视图对象类似于集合,并且支持交集和并集等常见的集合操作;values视图不是这样,因为它不唯一,不过当(key value)对是唯一而且可散列的化,items结果是这样。如下是键列表,用于集合操作的样子,在结合操作中,视图可能与其他的视图、集合和字典混合:

    如果字典项视图是可散列的,他们是类似与集合的,也就是说如果他们只包含不可变对象的话:

    16、keys不会返回一个列表,所以需要手动转换为一个列表:Ks = D.keys()

    或者直接>>>for k in sorted(Ks): print(k,d[k])。

    或者 >>> for  k in sorted(D) : print(k,D[k]).

    17、字典大小比较:

    18、3.0中的成员测试:

    六、元组、文件及其他(第9章)

    元组由简单的对象组构成,元组与列表非常类似,只不过其不能在原处修改,并且通常写成圆括号中的一系列项。虽然元组不支持任何方法调用,不过其具有列表的大多数属性:a、任意对象的有序集合;b、通过偏移量存取;c、属于不可变序列类型;d、固定长度、异构、任意嵌套;e、对象引用的数组。

    1、元组没有方法,不过却支持字符串和列表的一般序列操作比如+,*,【】索引【I:J】分片。不过这会返回新元组

    2、表9-1中因为表达式可以被圆括号括起来,为了识别用户想创建的是单个对象的元组,需要多一个逗号;在有多个创建的时候,可以省略圆括号。相比较来说,当元组作为常量传给函数调用以及元组在2.X版本的print语句中列出的特殊情况下,圆括号必不可少。

    3、如果需要排序,a、将其转换成列表成为一个可变对象,或者使用内置sorted方法:>>>tmp.list(T) ;>>>tmp.sort();>>> T = tuple(tmp);或者sorted(T)。

    4、列表解析也可以用于元组的转换:T = (1,2,3,4,5);  L = [X +20 FOR X in T ]。

    5、元组只有两个方法index 和count。元组的不可变性只适用于元组本身顶层而并非其内容。

    内置open函数可以创建一个python文件对象,用来作为计算机上的一个文件链接。在调用open之后,你可以通过调用返回文件对象的方法来读写相关外部文件。文件对象只是常见文件处理任务输出模块。多数文件方法都与执行外部文件相关的文件对象的输入和输出有关,但其他文件方法可查找文件中的新位置、刷新输出缓存等。

    6、打开文件:首先是外部名,接着是处理模式:a、在模式字符串尾部加上b 表示二进制数据处理(行末转换和3.0的unicode编码被关闭了);b、加上“+”意味着同时为输入和输出打开文件(也就是说,我们可以对相同文件对象进行读写,往往与对文件中的修改的查找操作配合使用)。要打开的两个参数都必须是python的字符串。第三个是可选参数,用来控制输出缓存:传入“0”意味着输出无缓存(写入方法调用时立即传给外部文件)。外部文件名参量可能包含平台特定的以及绝对惑相对目录路劲前缀。没有目录路径时,文件假定存在当前的工作目录中,即脚本运行的地方。

    7、使用文件:任何情况下,python程序中的文本文件都是字符串形式,读取文件会返回字符串形式的文本,文本作为字符串传递给write方法。:a、文件迭代器是最好的读取行工具,现在从文本文件读取文字航的最佳方式是根本不要读取该文件;b、内容是字符串,而不是对象,所以从文件中读取的数据回到脚本时是一个字符串,需要对应的转换,当把数据写入文件时,python不会自动把对象转换为字符串,需要传递一个格式化的字符串;c、close是通常选项;d、文件是缓冲的并且是可查找的,python文件也是在字节偏移的基础上随机访问的,他们的seek方法允许脚本跳转到指定的位置读取或写入。

    8、应用文件的一个例子:

    如果想要显示带有末行字符解释的文件内容,用文件对象的read方法把整个文件读入到一个字符串中,并打印它:

    如果要一行一行的扫描:

    9、python总是支持文本和二进制文件,在3.0中二者之间有些差别:a、文本文件把内容表示为常规的str字符串,自动执行unicode编码和解码,并且默认执行末行转换。;b、二进制文件把内容表示为一个特殊的bytes字符串类型,并且允许程序不修改的访问文件内容。在3.0中,通常你必须使用bytes字符串处理二进制文件,并且用常规的str字符串处理文本文件,此外,由于文本文件实现了unicode编码,不能以文本模式打开一个二进制数据文件--将其内容解码为unicode文本可能会失败。

    10、当读取一个二进制数据文件的时候,得到一个bytes对象--表示绝对字节值的较小整数的一个序列,其外观几乎与常规的字符串完全相同:

    而且二进制文件不会对数据执行任何末行组韩圜。

    11、在文件中存储并解析python对象:

    在读取的时候,交互模式的回显给出的正确的字节内容,而print语句则会解释内嵌行终止符来给出用户友好结果:

    12、有时候会使用字符串的rstrip来删除最后部分的"\n",不过int和一些其他转换方法会忽略数字旁边的空白。在转换11中第三行的时候,可以使用eval内置函数将字符串转换成可执行程序代码(也就是含有python表达式的字符串):

    13、不过eval有时候太过强大,它会执行python的任何表达式,甚至有可能会删除计算机上所有文件的表达式,只要给予必要的权限。如果真的想储存python原生对象,但又无法信赖文件的数据来源,python标准库pickle模块会是个理想的选择。该模块是能够让我们直接在文件中储存几乎任何python对象的高级工具,也不要求我们把字符串转换来转换去,它就像一个通用的数据格式化和解析工具。例如在文件中存储字典:

    之后想要取回字典,只要在用一次pickle重建就行:

    pickle模块执行所谓的对象序列化,也就是对象和字节字符串之间的相互转换。这里,在pickle内部将字典转成字符串形式。ps:我们是用二进制模式打开用来存储pickle化的对象的文件,二进制模式总是python3.0中必需的,因为pickle程序创建和使用一个bytes字符串的对象,并且这些对象意味着二进制模式文件(文本模式文件意味着3.0中的str字符串)。早期的python,协议0使用文本模式文件是没问题的(默认创建ascii文本),;较高的协议要求二进制模式文件。3.0的默认协议是3(二进制),但是它即使对于协议0也创建bytes。2.6中pickle的优化版本cPickle模块可以直接导入以提高速度,3.0中改名为_pickle,并且在pickle中自动使用它。

    14、struct模块可以构造并解析打包的二进制数据,从某种话说,它是另一个数据转换工具,它能够把文件中的字符串解读为二进制数据。例如:用‘wb’模式打开一个文件,并将一个格式化字符串和几个python对象传给struct:

    上图中‘>i4sh’是格式化字符串,指的是一个4字节整数、一个包含4个字符的字符串以及一个2位整数的数据包,所有的这些都按照高位在前(big-endian)的形式。(更详细的使用help(struct))。

    15、文件上下文管理器:在33章有更详细的:

    16、虽然open函数极其返回的文件对象是python脚本中通向外部文件的主要接口,python工具集中还有其他类似的文件工具,还有其他可用的:a、标准流,在sys模块中预先打开的文件对象;b、os模块中的描述文件,处理整数文件、支持例如文件锁定之类的较低级工具;c、sockets、pipes和FIFO文件,文件类对象,用于同步进程或者通过网络进行通信;d、通过键来存取的文件;e、shell命令流,像os.open和subprocess.Popen这样的工具,支持产生shell命令,并读取和写入到标准流。不过第三方开源的比如PySerial扩展中支持与窗口交流,以及pexpect系统中的交互程序。

    17、这里进行python核心内置类型的分类:

    a、对象根据分类来共享操作:字符串、列表和元组都共享诸如合并、长度和索引等序列操作;b、只有可变对象(列表、字典和集合)可以原处修改;不能原处修改数字、字符串或元组;c、文件导出唯一的方法,所以可变性不真的适用于他们-当处理文件的时候,他们的状态可能会修改;d、上表中的数字包含了所有的数字雷系:整数、浮点数、复数、小数和分数;e、上表中字符串包括str以及3.0中的bytes和2.6中的unicode;3.0中的bytearray字符串类型是可变的;f、集合类似与一个无值的字典的键,但是不能映射为值,并且没有顺序,因此,集合不是一个映射类型或者一个序列类型,forzenset是集合的一个不可变的版本。;g、除了类型分类操作,上表中的所有类型都有可调研的方法,不过通常特定与他们的类型。

    18、一般来说,a、列表、字典和元组可以包含任意种类的对象;b、列表、字典和元组可以任意嵌套;c、列表和字典可以动态的扩大缩小。而且因为python的符合对象类型支持任意结构,所以例如:字典的值可以是列表,而这个列表可能包含元组,而元组又可能包含字典。

    19、在赋值操作中,是将对象的引用给新的变量,而不是对对象进行拷贝,如果你想要复制对象,那么就明确的告诉python你想这么做。a、没有限制条件的分片表达式(L【:】)能够复制字典;b、字典的copy方法(X.copy())能够复制字典;c、有些内置函数(比如list)能够生成拷贝(list(L));d、copy标准库模块能够生成完整拷贝。>>>A = L[:]  和>>>B = D.copy()。所以如果在其他地方填入的时候,可以使用完整分片来进行复制X【:】这样。ps:不过需要注意的是,无条件值的分片以及字典copy方法只能做顶层复制,也就是说不能够复制嵌套的数据结构,不然就得使用标准的copy模块,import

    copy;并使用>>>x=copy.deepcopy(Y)。

    20、python的比较操作--测试相等性,相对大小等,当嵌套对象存在时,python会自动遍历数据结构,而且不断的深入。一般来说,python中不同的类型的比较方法如下:a、数字通过相对大小进行比较;b、字符串按照字典顺序,一个字符接着一个字符的进行比较;c、列表和元组从左到右对每部分内容进行比较;d、字典通过排序后的(键、值)列表进行比较,字典的相对大小比较在3.0中不支持;e、数字混合雷系比较(比如1< 'spam')在3.0中是错的,需要同类型比较。

    21、在python中真假的含义是0代表假,1代表真,而且将任何空数据结构视为假,任何非空视为真:

    在python中有个特殊的对象:None,这个总被认为是假。用来做空的占位作用,类似于C中的NUll。

    22、类型本身在python中也是对象类型。在2.2版本中每个核心类型都有个新的内置名来支持面向对象子类的类型定制:dict、list、str、tuple、int、float、complex、byte、type、set和file(在2.6中file也是类型名称,是open的同义词,不过3.0中不是)。调用这些名称其实就是调用对象构造函数,而不仅仅是转换函数。不过在3.0中,类型标准库模块提供其他不能作为内置类型使用类型的名称,而是用isinstance函数进行类型测试:

    上面所有的类型测试都为真。因为目前python的类型也可以再分为子类,一般都建议使用isinstance技术:

     p264

    23、除了上面介绍的几种核心对象之外,后续说道的函数、模块和类,典型的python安装还有几十种其他可用的对象类型,允许作为c语言的扩展程序或是python的类:正则表达式对象、DBM文件、GUI组件、网络套接字等。

    展开全文
  • 但是,计算机处理的远不止数值,还可以处理文本、图形、音频、视频、网页等各种各样的数据不同的数据,需要定义不同的数据类型。在Python中,能够直接处理的数据类型有以下几种:数值型、字符串型、列表型、元组...

    Python的数据类型

    计算机顾名思义就是可以做数学计算的机器,因此,计算机程序理所当然地可以处理各种数值。但是,计算机能处理的远不止数值,还可以处理文本、图形、音频、视频、网页等各种各样的数据,不同的数据,需要定义不同的数据类型。在Python中,能够直接处理的数据类型有以下几种:数值型、字符串型、列表型、元组型、字典型。

    数值类型

    顾名思义就是数字类型,但数字类型内部又分为:整型、浮点型、长整型、复数型

    整数类型

    整数类型的范围是2**32,其中包含正数和负数(2的31次方个正和2的31次方的个负数,所以它的范围是-2147483648 ——— 214748364。

    PS:查看一个数据的类型使用type(数据)方法

    In [1]: a=1

    In [2]: type(a)

    Out[2]: int # int表示为整型

    In [18]: type(2/1)

    Out[18]: int

    浮点型

    浮点类型就是带小数点的,多余的位数会被四舍五入。

    整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的(除法难道也是精确的?是的!),而浮点数运算则可能会有四舍五入的误差。

    In [3]: a=1.23

    In [4]: type(a)

    Out[4]: float  # float表示的是浮点数

    In [19]: type(2.0/1)

    Out[19]: float

    长整型

    用l或L表示,当我们赋值的时候使用l可以把变量赋值为长整型,注意在Python3中已经取消了长整型这个格式。

    In [11]: a=1299999999999999999999999999999999999999999

    In [12]: type(a)

    Out[12]: long    #long表示长整型

    In [13]: a

    Out[13]: 1299999999999999999999999999999999999999999L

    In [15]: a=123l

    In [16]: type(a)

    Out[16]: long

    #只有python2.x中有长整型的概念,python3.x只有整型

    复数型

    用j表示,当我们赋值的时候使用j可以把变量赋值为复数型,python对复数提供内嵌支持。(其他大部分软件没有)

    复数一般用于科学计算,我们日常一般不会使用,这里知道即可。

    In [20]: type(123j)

    Out[20]: complex # 表示复数类型

    字符串类型

    字符串是以单引号'或双引号"括起来的任意文本,比如'abc',"xyz"等等。请注意,''或""本身只是一种表示方式,不是字符串的一部分,因此,字符串'abc'只有a,b,c这3个字符。如果'本身也是一个字符,那就可以用""括起来,比如"I'm OK"包含的字符是I,',m,空格,O,K这6个字符。有三种方法定义字符串:单引号,双引号,三引号。

    str='this is string'

    str="this is string"

    str='''this is string''' #也可以是三个双引号,三个引号可以多行注释但是不能单双混合

    其中三重引号除了能定义字符串以外,还可以表示注释。

    字符串的基本操作

    字符串是一个序列,可以通过索引和切片去操作

    索引

    类似数组的下标:

    In [3]: a='1234567'

    In [4]: a[0] -->#下标从0开始,0表示第一个数

    Out[4]: '1'

    In [5]: a[3] -->#表示第四个数

    Out[5]: '4'

    切片

    类似shell变量的截取:

    In [14]: a='abcd'

    In [15]: a[0:2]

    Out[15]: 'ab'

    #从第0个开始截取2个字符,其中0可以省略

    In [14]: a='abcd'

    In [16]: a[:-1]

    Out[16]: 'abc'

    #默认是从左往右(前往后),带减号,表示从右往左(后往前),-1表示最后一个字符(a='abcd',-1的值是d,也就是3,顾a[:-1],就等于a[0:3])

    In [14]: a='abcd'

    In [17]: a[1:]

    Out[17]: 'bcd'

    #从1开始截取到最后

    In [14]: a='abcd'

    In [20]: a[::2]

    Out[20]: 'aceg'

    #步长为2,表示从0开始步长为2,(取0,2,4,6)

    In [26]: a

    Out[26]: 'abcdefg'

    In [27]: a[-5:-1]

    Out[27]: 'cdef'

    #表示倒着取,从倒数第五个取到倒数第一个(不包含倒数第一,要想取可以使用a[-5:])

    In [29]: a

    Out[29]: 'abcdefg'

    In [30]: a[0:5:1]

    Out[30]: 'abcde'

    In [31]: a[0:5:2]

    Out[31]: 'ace'

    #从0开始取到第5个,步长为1,步长为2

    In [32]: a

    Out[32]: 'abcdefg'

    In [34]: a[-1::-1]

    Out[34]: 'gfedcba'

    #从后往前取,步长为-1,表示每次倒着取1个,由于没有指定结尾,默认到最后,所以就把数字逆了过来。

    In [36]: a

    Out[36]: 'abcdefg'

    In [38]: a[::2][:2]

    Out[38]: 'ac'

    #表示先每隔2个取出来,然后从头开始取2个。

    字符串的内置方法

    字符串是Python中的主要数据类型,其内置了非常多的方法,主要方法如下:

    # 功能:首字母大写

    # 调用方式:string.capitalize()

    # 例:

    name = 'hello' name.capitalize()

    #结果:

    'Hello'

    capitalize

    # 3.x新增 字符串转换为小写,可以转换各种语言大小写(法语、德语...)

    # 用法 :string.casefold()

    例子:

    name = 'HELLO'

    name.casefold()

    结果: 'hello'

    casefold

    # 功能:字符串转换为小写,只能转换英文字母

    # 用法:string.lower()

    例:

    name = 'World'

    name.lower()

    结果:

    'world'

    lower

    # 功能:文本填充,width为字符串的总长度,str居中然后两端用fillcharacter填充,fillchar默认为空格

    # 用法:str.center(width,filechar=None)

    例:

    name = 'hello'

    name.center(7,'*')

    结果:

    *hello*

    center

    # 功能:sub为统计的字符串(子序列),统计sub出现的次数,start为起始位置,end为结尾位置

    # 用法:str.counter(sub,start=None,end=None)

    例:

    name = 'hello'

    name.counter('l')

    结果:

    2

    counter

    # 功能:以suffix为开头,返回bool值,start起始位置,end结束位置

    # 用法:str.startswith(suffix,start=None,end=None)

    例:

    name = 'Hello'

    name.startswith('H')

    结果:

    True

    startswith

    # 功能:以suffix为结尾,返回bool值,start起始位置,end结束位置

    # 用法:str.endswith(suffix,start=None,end=None)

    例:

    name = 'world'

    name.endswith('d')

    结果:

    True

    endswith

    序列类型

    字符串、列表和元组都是序列的一种,序列的两个主要特点是索引操作符和切片操作符

    索引操作符让我们可以从序列中抓取要给特定的项目

    切片操作符让我们能够获取序列的一个切片,即一部分操作

    序列类型的基本操作方法

    序列同样支持索引和切片操作,但是字符串、列表、元组的索引和切片又有些许不通

    len()

    计算字符串的长度

    In [7]: a='123'

    In [8]: len(a)

    Out[8]: 3

    In [9]: len('123')

    Out[9]: 3

    +

    加号在这里并不是加减乘除的意思,而是用来连接两个序列

    In [10]: a

    Out[10]: '123'

    In [11]: a + '4'

    Out[11]: '1234'

    #字符串和数字不能连接到一起

    *

    重复序列元素(字符串的时候)

    In [18]: '#' * 10

    Out[18]: '##########'

    #当变量为数字的时候就为乘了。

    in

    判断元素是否在序列中

    In [23]: a = 'abcd'

    In [24]: 'a' in a

    Out[24]: True

    #当字符串在某个序列中的时候返回真,否则返回假(not in表示不在)

    max(),min()

    求最大值和最小值

    In [25]: max(a)

    Out[25]: 'd'

    In [26]: min(a)

    Out[26]: 'a'

    In [27]: a

    Out[27]: 'abcd'

    注意:如果对字符进行对比,程序内部会把字符转换成ascii码对应的数字进行比较。

    >>> ord('a')

    97

    >>> ord('b')

    98

    >>> ord('c')

    99

    >>>

    cmp()

    比较两个序列是否相等

    #若相等则返回0,若前大于后则返回正数,若后大于前则返回负数

    In [30]: cmp("123","456")

    Out[30]: -1

    In [33]: cmp("789","456")

    Out[33]: 1

    In [34]: cmp("456","456")

    Out[34]: 0

    #注意cmp的比较是从左向右开始比对的,大于就返回1,小于就返回-1,等于就继续向后比对

    In [43]: cmp('5','456')

    Out[43]: 1

    In [44]: cmp('45','456')

    Out[44]: -1

    In [45]: cmp('455','456')

    Out[45]: -1

    In [46]: cmp('457','456')

    Out[46]: 1

    元组概念

    元组(类型为 tuple)和列表十分相似

    元组和字符串一样是不可变的

    元祖的特点

    元组可以存储一系列的值,使用括号来定义。

    元组通常用在用户定义的函数能够安全的采用一组值的时候,即被使用的元组的值不会改变,不可变的含义是:不能改变这个值中的某个字符。

    元祖也通常用来接收函数的返回值。

    In [8]: a='123456'

    In [9]: a[-1]

    Out[9]: '6'

    In [10]: a[-1]=1

    ---------------------------------------------------------------------------

    TypeError Traceback (most recent call last)

    in ()

    ----> 1 a[-1]=1

    TypeError: 'str' object does not support item assignment

    In [11]:

    #变量a是可以被定义成任何值的,但是不能在定义之后,修改里面的值,如果想要修改就需要重新定义这个变量

    In [11]: a='123451'

    In [13]: a[-1]

    Out[13]: '1'

    定义一个元组

    使用()来表示定义的是元组,但是如果元组里面的值只有一个的话,需要加在值后面加上,(逗号),表示是一个元组。

    另外,元组中可以同时储存不同类型的数据,也可以引用其他元组。

    In [18]: t=(1)

    In [19]: type(t)

    Out[19]: int

    In [20]: t=(1,)

    In [21]: type(t)

    Out[21]: tuple # tuple表示元组类型

    #引用其他元组

    In [22]: a=(1,2,3)

    In [23]: t=('123',a)

    In [24]: t

    Out[24]: ('123', (1, 2, 3))

    #通过索引只引用某一个值

    In [27]: t=('123',a[1])

    In [28]: t

    Out[28]: ('123', 2)

    元祖的基本操作方法

    元组和其他数据类型相同,它支持的操作如下。

    元祖的拆分

    通过变量去接收元组中的值

    In [34]: a=('123','456')

    In [35]: first,second=a   --> # 定义first接收元组的第一个值,second接收元组的第二个值

    In [36]: first

    Out[36]: '123'

    In [37]: second

    Out[37]: '456'

    #注意接收值的变量要与元组中的值的个数保持一致,若元组中有3个值,必须定义三个变量去接收,否则无法接收(当元组中有两个值的时候,用一个变量去接不会报错,但是也还是用元组的形式表达)

    PS:假如元祖中有三个元素,那么我们可以定义3个变量来接受元祖的值,如果元祖中有4个元素,那么我们只能通过定义1个或者定义4个来接受,定义1个就等于元祖复制,定义4个才表示接受元素

    PS:如果我们不想要某个元素的时候,可以使用_,来获取,分割元组的时候可以有如下操作。

    >>> a = ('a','b','c','d')

    >>> a,b,_,d = a

    >>> a

    'a'

    >>> b

    'b'

    >>> d

    'd'

    >>>

    _忽略部分元素的方法

    元组的方法

    如果安装了ipython可以通过tab键查看元组的方法,如果没有安装,就需要使用dir(元组名)去查看了

    # 会列出一些内饰的属性,和方法

    >>> dir(a)

    ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

    >>>

    # 已__开头的先忽略,后面会讲,所以可以看到有两个方法。

    # 使用help查看使用方法

    In [3]: help(a.count)

    count(...)

    T.count(value) -> integer -- return number of occurrences of value

    # a.count(value) 用来统计value在元组中出现的次数,不存在返回0。

    In [4]: a=('1','2','3')

    In [7]: a.count("4")

    Out[7]: 0

    In [8]: a.count("1")

    Out[8]: 1

    # a.index(value) 用来返回value在元组中的索引,如果value不在元组中,则会报错。如果有多个,默认返回第一个(可以指定从哪个索引开始查找到某个索引结束,指定范围区间)

    In [4]: a=('1','2','3')

    In [9]: a.index('1')

    Out[9]: 0

    In [10]: a.index('3')

    Out[10]: 2

    >>> t1

    ('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')

    >>> t1.index('a',5,7)

    6

    列表类型

    列表(类型为 list)是处理一组有序项目的数据结构,即可以在列表中存储一个序列的项目。

    列表是可变类型的数据,创建列表使用[]中括号。

    列表的基本操作

    list是一种有序的集合,可以随时添加和删除其中的元素。它的方法有很多,这里列举主要的方法。

    创建一个空的列表

    # 1、创建一个空列表

    list1 = []

    list2 = list() # 工厂函数

    # 2、创建列表并赋值

    list3 = ['a',1,2]

    # 3、列表可以包含变量,元组,列表等

    In [15]: a=123

    In [16]: b=['123',a,(1,),["hello","python"]]

    In [17]: b

    Out[17]: ['123', 123, (1,), ['hello', 'python']]

    In [24]: len(b)

    Out[24]: 4

    #一共有4个变量

    # 4、列表的值是可以改变的

    In [25]: b

    Out[25]: ['123', 123, (1,), ['hello', 'python']]

    In [26]: b[0]

    Out[26]: '123'

    In [27]: b[0]=456

    In [29]: b

    Out[29]: [456, 123, (1,), ['hello', 'python']]

    列表的追加

    使用append在list的后面(右边)

    In [30]: a=[]

    In [31]: type(a)

    Out[31]: list

    In [32]: a.append("linux")

    In [33]: a

    Out[33]: ['linux']

    列表的组合

    使用+,对多个列表进行拼接

    In [32]: a = [456, 123, (1,)]

    In [33]: b = [['hello', 'python'], 'linux']

    In [34]: b + a

    Out[34]: [456, 123, (1,), ['hello', 'python'], 'linux']

    In [35]: (b + a) * 2 # 重复2次

    Out[35]:[456, 123, (1,), ['hello', 'python'], 'linux', 456, 123, (1,), ['hello', 'python'], 'linux']

    >>>

    列表的删除

    使用list的remove方法删除一个元素

    In [38]: b = [456, 123, (1,), ['hello', 'python'],'love']

    In [39]: b.remove('love')

    In [40]: b

    Out[40]: [456, 123, (1,), ['hello', 'python']]

    #直接移出元素名,如果有两个,则默认删除匹配的第一个。

    In [55]: b

    Out[55]: [123, 456, ['hello', 'python'], '123', (1,)]

    In [56]: del b[0]

    In [57]: b

    Out[57]: [456, ['hello', 'python'], '123', (1,)]

    #如果知道变量的索引可以直接通过del来进行删除,del还可以直接删除变量

    列表的反转

    使用list的reverse方法进行原地倒序。

    In [41]: b = [456,123, (1,),['hello', 'python']]

    In [42]: b.reverse()

    In [43]: b

    Out[43]: [['hello', 'python'], (1,), 123, 456]

    列表的插入

    使用list的insert进行数据的插入

    In [47]: b

    Out[47]: [456, 123, (1,), ['hello', 'python']]

    In [48]: b.insert(0,'123')

    In [49]: b

    Out[49]: ['123', 456, 123, (1,), ['hello', 'python']]

    # 在索引0的位置插入一个元素‘123’

    查找列表中变量

    In [62]: b

    Out[62]: [456, ['hello', 'python'], '123', (1,)]

    In [63]: '123' in b

    Out[63]: True

    In [65]: "a" in b

    Out[65]: False

    # 存在返回True,否则返回False

    变量的修改

    In [68]: b

    Out[68]: [456, ['hello', 'python'], '123', (1,)]

    In [69]: b[0]='123'

    In [70]: b

    Out[70]: ['123', ['hello', 'python'], '123', (1,)]

    # 修改b的索引0的元素值为‘123’

    字典类型

    使用大括号定义,是Python中唯一的映射类型(哈希表)

    字典对象是可变的,但是字典的键必须使用不可变对象,一个字典中可以使用不同类型的key。像元组,字符串等都是不可变的,都可以作为key。而列表是可变的,无法作为key。key是唯一的

    字典的方法

    字典有很多的方法,这里仅列举常用的方法,其他方法可以使用dir(dict)查看keys() 获取字典的key

    values() 获取字典中所有的values

    items() 把字典转换成列表

    get() 如果字典中有该key,则返回key值,如果没有,则返回空,也可以自己定义返回值

    dic.get('Name','python'),如果存在name,则返回values,否则返回Python

    has_key('key') 判断key的是否存在,存在返回True,否则返回False

    dic1 = dic.copy() 拷贝字典到一个新的字典中去

    clear() 清除字典中的元素

    pop() 删除一个key,同时打印该key的value,如果key不存在,则返回keyerror,或者指定返回值 dic.pop('name',True)

    update() 把一个字典更新(添加)到另一个字典中

    fromkeys(s,value) 把序列s,作为字典的key,如果不给value,则默认是none,如果指定value,那么所有key对应的值都为value

    类型转换

    注意虽然在Python中有很多的数据类型,但是这些类型是可以相互转换的,那么就要用到了俗称工厂函数的东西:str、list、dict、tuple等等。str():用于把整型、浮点型等转换为字符串

    list():用于把一个可迭代对象转换为列表

    dict():把一个可迭代对象(每次迭代返回两个数据),转换为字典

    tuple():把一个可迭代对象转换为元组

    运算符表达式

    python运算符:赋值运算符、算数运算符、关系运算符、逻辑运算符

    python表达式:是将不同的数据(包括变量、函数)用运算符号按一定规则连接起来的一种式子。

    赋值运算符

    = 表示赋值,当把数字赋值给一个变量的时候不用加引号,而赋值字符串给变量的时候就需要加引号了,否则python认为你赋值的是另一个变量。

    =:x=3 ,y='abc'

    += :x+=2,表示x=x+2

    -=:x-=2,表示x=x-2

    *=:x*=2,表示x=x*2

    /=:x/=2,表示x=x/2

    %=:x%=2,表示取余,x对2取余数,加入x=6,那么取余为0

    PS:Python下不用指定变量的类型,它会自动根据你赋值的类型来定,使用type(x) 来查看变量的类型。

    算数运算符

    + 加 用来计算数字,如果字符串、列表等相加,等于是把两个对象拼到一起

    - 减

    * 乘

    / 除,4/3,默认是整除,为了得到小数,可以把其中一个变量变成浮点型,4.0/3或4/3.0

    // 表示只取整数,4.0/3 答案是1.33333,如果用4.0//,因为取整则,答案是1

    % 取余数

    ** 表示乘方 2**3 表示2的3次方

    关系运算符

    返回值为布尔值:true or false

    > 1>2,值是false

    < 1<2,值是true

    >= 1>=2,值是false

    <= 1<=2,值是true

    == 1==2,值是flase

    != 1!=2,值是true

    逻辑运算符

    返回值为布尔值:true or false

    and:逻辑与,只要有1个是false那么值就是false,1==2 and 1<2 ,值是false, 1!=2 and 1<2,值是true

    or:逻辑或,只要有一个是true那么值就是true,1=2 and 1<2 ,值是true

    not:逻辑非,取反 not 1<2,值是true

    其他特殊符号

    in/no in 成员测试,测试一个元素是否在一个序列中

    is /is not 统一性的测试

    练习

    写一个四则运算器,从键盘读取数字可以使用input()或raw_input()

    input()函数,一般用来接收数字,当我们输入字符串的时候,它会报错,如果需要用字符串那么需要用引号引起来

    raw_input()函数,一般用来接收字符串,当我们输入数字的时候,它也会用引号引起来,表示是字符串

    input方式

    #!/usr/bin/env python

    # _*_coding:utf-8_*_

    # __time__: 2017/10/17 22:54

    # __author__: daxin

    # __file__: text.py∂

    num1 = input("Please input a number:")

    num2 = input("Please input a number:")

    print " %s + %s = %s " % (num1,num2,num1+num2)

    print " %s - %s = %s " % (num1,num2,num1-num2)

    print " %s * %s = %s " % (num1,num2,num1*num2)

    print " %s / %s = %s " % (num1,num2,num1/num2)

    展开全文
  • Python程序可以分解成模块、语句、表达式、以及对象程序由模块构成模块包含语句语句包含表达式表达式建立并处理对象Python内置类型Python核心数据类型数字 1234字符串 'sad'列表 [1,[2,'three'],4]字典 ['food':'...
  • python 3更新中,不再支持 str 和 int 直接判定>>> a = ‘10‘>>> a > 9Traceback (most recent call last):File "", line 1, in a > 9TypeError: ‘>‘ not supported between ...
  • 注释:1.单行注释:使用 # 来给代码添加单行注释,提高可读性,增强效果2.多行注释:使用 ''' 开头,使用 ''' 来结束,一般用于多行代码或解释语句来注释变量和数据...计算机处理的数据有很多种类型,除了数值之...
  • 在这里我想探讨一下“互相关”中一些概念。正如卷积有线性卷积(linear convolution)和循环卷积(circular...线性互相关和循环互相关基本公式是一致不同之处在于如何处理边界数据。其本质的不同在于它们对原始...
  • 这说明,age是个string类型,而string和integer是不能比较。于是在input外加了int ()即可
  • 首先有几个原则: 1.byte,short,char变量之间(注意是变量,常量不同运算时候直接转换成int类型再计算。  如果这些变量与常量做运算就保留...3.boolean类型不能强制转换为其它类型 例子: int i1 = 123;   i
  • 统计系统剩余的内存 ...需要:有时候我们要把不同的数据类型做一起计算,这时就需要把两个不同的数据类型转换为同种数据类型,否则不同的数据类型不能做计算,比如,字符串之间是不能做加减乘除运算的,必须转化为...
  • 数据类型转换自动数据类型转换手动(强制)数据类型转换混合运算类型转换int 和 String 之间相互转换 自动数据类型转换 long 表示范围更大, 可以将 int 赋值给 ...int 和 boolean 是毫不相干两种类型, 不能相互
  • 而数组是做不到的,因为数组是单一数据类型的数据集合,它本身不是数据类型(而结构体是),数组名称是常量指针,所以不可以做为左值进行运算,所以数组之间就不能通过数组名称相互复制了,即使数据类型和数...
  • 结构体类型

    2016-07-31 21:43:39
    第二,相同结构的结构体变量是可以相互赋值的,而数组是做不到的,因为数组是单一数据类型的数据集合,它本身不是数据类型(而结构体是),数组名称是常量指针,所以不可以做为左值进行运算,所以数组之间就不能通过...
  • 一、结构体   一般自己构造的数据结构类型(如数组)这只能放...只能低变量进行赋值,存取和运算不能对一个类型。在编译时是不会给类型分配内存空间的,只能对变量分配内存空间。对结构的成员可以单独使用。结构体
  • Java 类型转换

    2021-02-02 16:52:03
    不同类型数据转化为同一类型,然后进行运算。 小数优先级比整数高 类型 方法 方向 强制转换 类型 变量名 =(类型)变量名 高–低 自动转换 类型 变量名 = 变量名 低–高 注意: 不能对布尔值进行...
  • C#数据结构

    2013-12-10 11:49:54
    对于一个特定的问题,采用的数据结构不同,其设计的算法一般也不同,即 使在同一种数据结构下,也可以采用不同的算法。那么,对于解决同一问题的 同算法,选择哪一种算法比较合适,以及如何对现有的算法进行改进,...
  • 因为数组是单一数据类型的数据集合,他本身不是数据类型(而结构体是),数组名称是常量指针,所以不能做为左值进行运算,所以数组之间不能通过数组名称相互复制了,即使数据类型和数组大小完全相同。  定义...
  • c++结构体

    千次阅读 2012-04-04 22:11:09
    因为数组是单一数据类型的数据集合,它本身不是数据类型(而结构体是),数组名称是常量指针,所以不可以做为左值进行运算,所以数组之间就不能通过数组名称相互复制了,即使数据类型和数组大小完全相
  • 大话数据结构

    2019-01-10 16:35:22
    不能非要去被毒蛇咬一口才知道蛇不可以去招惹吧。 2.11最坏情况与平均情况 35 2.12算法空间复杂度 36 事先建立一个有2050大数组,然后把所有年份按下标数字对应,如果是闰年,此数组项值就是1,如果不是就是0...
  • 而数组是做不到的,因为数组是单一数据类型的数据集合,它本身不是数据类型(而结构体是),数组名称是常量指针,所以不可以做为左值进行运算,所以数组之间就不能通过数组名称相互复制了,即使数据类型和数组大小完全...
  • 大话数据结构 程杰

    2018-09-01 10:06:43
    不能非要去被毒蛇咬一口才知道蛇不可以去招惹吧。 2.11最坏情况与平均情况 35 2.12算法空间复杂度 36 事先建立一个有2050大数组,然后把所有年份按下标数字对应,如果是闰年,此数组项值就是1,如果不是就是0...
  • 而数组是做不到的,因为数组是单一数据类型的数据集合,它本身不是数据类型(而结构体是),数组名称是常量指针,所以不可以做为左值进行运算,所以数组之间就不能通过数组名称相互复制了,即使数据类型...
  • 数据结构 1800题》

    热门讨论 2012-12-27 16:52:03
    (3)在给定的逻辑结构及其存储表示上可以定义不同运算集合,从而得到不同的数据结构。这样说 法对吗?举例说明之。 (4)评价各种不同数据结构的标准是什么? 5.评价一个好的算法,您是从哪几方面来考虑的? ...
  • 不能非要去被毒蛇咬一口才知道蛇不可以去招惹吧。 2.11最坏情况与平均情况 35 2.12算法空间复杂度 36 事先建立一个有2050大数组,然后把所有年份按下标数字对应,如果是闰年,此数组项值就是1,如果不是就是0...
  • 技巧170 分类项相同的数据表合并计算 技巧171 让合并计算结果自动动态更新 技巧172 快速录入引用位置区域 技巧173 引用其他工作簿数据 技巧174 在合并计算中使用名称 技巧175 使用合并计算进行分类汇总 ...
  • 大话数据结构-程杰

    2014-07-13 23:45:52
    不能非要去被毒蛇咬一口才知道蛇不可以去招惹吧。 2.11 最坏情况与平均情况 35 2.12 算法空间复杂度 36 事先建立一个有2050大数组,然后把所有年份按下标数字对应,如果是闰年,此数组项值就是1,如果不是...
  • 什么是结构体?...而数组是做不到的,因为数组是单一数据类型的数据集合,它本身不是数据类型(而结构体是),数组名称是常量指针,所以不可以做为左值进行运算,所以数组之间就不能通过数组名称相互复制...

空空如也

空空如也

1 2 3 4 5 6
收藏数 107
精华内容 42
关键字:

不同类型的数据不能相互运算