码迷,mamicode.com
                                                                              首页 > 编程语言 > 详细

                                                                              python基本知识(二):数据类型

                                                                              时间:2019-05-09 13:45:58      阅读:27      评论:0      收藏:0      [点我收藏+]

                                                                              标签:传递   数字   encoding   拷贝   ...   ide   instance   长度   rewrite   

                                                                              ‘‘‘
                                                                              数据类型: 1. 包括:
                                                                              基本数据类型: num(int, float), str, bool, None
                                                                              高级数据类型: list, tuple, dict, set, slice
                                                                              2. 操作:
                                                                              isinstance(a,DataModel) # 变量是否是某个类型的实例
                                                                              type(a) # 变量类型
                                                                              id(a) # 变量内存地址
                                                                              ‘‘‘ # 综述

                                                                              ‘‘‘
                                                                              Num: 1. 数值操作: +, -, *, /, //(取商), %(取余), **(次方)
                                                                              2. 数值方法:
                                                                              1) 进制转换:
                                                                              1>. int(‘str‘,[2,8,16]) # 二进制, 八进制, 十进制(默认),十六进制 字符串 转十进制数值
                                                                              2>. bin(num) # 十进制(10), 八进制(0o12), 十六进制(0xA) 数值 转二进制字符串
                                                                              3>. oct(num) # 二进制(0b1010), 十进制(10), 十六进制(0xA) 数值 转八进制字符串
                                                                              4>. hex(num) # 二进制(0b1010), 十进制(10), 八进制(0o12) 数值 转十六进制字符串

                                                                              2) float(‘str‘) # 将数组str转为float, 有其他字符则报错
                                                                              3) divmod(a,b) # a/b返回一个tuple, 包括(,)
                                                                              4abs(num)
                                                                              5) max(Iterable,[key=func]), min(Iterable,[key=func])
                                                                              6) sum(Iterable)
                                                                              7) bytes(num/str,encoding=‘utf8‘) # 转为二进制字符串
                                                                              ‘‘‘ # Num

                                                                              ‘‘‘
                                                                              Str:
                                                                              1. split: 字符串分割
                                                                              1) s.split(‘a‘) # 从左边开始, 将字符串s‘a‘分割, 存入list并返回(不包括‘a‘)
                                                                              2) s.rsplit(‘a‘) # 从右边开始,
                                                                              3) s.partition(‘a‘) # 从左边开始, 将字符串s‘a‘分割成三部分, 存入tuple并返回(包括‘a‘)
                                                                              4) s.rpartition(‘a‘) # 从右边开始

                                                                              2. strip: 跳过一些字符
                                                                              1) s.strip(‘a‘) # 左右检测, 若有‘a‘则跳过
                                                                              2) s.lstrip(‘a‘) # 左边检测,
                                                                              3) s.rstrip(‘a‘) # 右边检测

                                                                              3. find: 查找字符串
                                                                              s.find(‘a‘,i,j) # s中查找‘a‘, 可设置查找的起止点[i,j), 0开始, 返回‘a‘s中的下标

                                                                              4. count: 计数
                                                                              s.count(‘a‘,i,j) # s中查找‘a‘并计数, 可设置查找的起止点[i,j), 0开始, 返回数值

                                                                              5. replace: 替换
                                                                              1) s.replace(‘a‘,‘b‘,i) # s中的‘a‘替换为‘b‘, 可设置替换i
                                                                              2) replace_map = str.maketrans(‘a‘,‘b‘) # 制作替换的规则
                                                                              s.translate(replace_map) # 可多次利用

                                                                              6. center/ljust/rjust: 字符填充
                                                                              1) s.center(width,‘a‘) # 字符串‘s‘居中, 其余填充为‘a‘, 总长度为width
                                                                              2) s.ljust(width,‘a‘) # 字符串‘s‘居左
                                                                              3) s.rjust(width,‘a‘) # 字符串‘s‘居右

                                                                              7. join: 字符连接
                                                                              a.join(‘s‘) # ‘a‘连接字符串‘s‘的每一个字符

                                                                              8. encode/decode: 字符编码
                                                                              1) 字符串 <--> encode/decode <--> 机器码
                                                                              2) 字符编码的规则: Unicode(2B), ASCII(1B), UTF-8(英文1B, 中文3B), GBK(英文1B, 中文2B)
                                                                              3)用处: 1>>. 保存数据:
                                                                              2>>. 传输数据:
                                                                              发送方: ‘ABC‘.encode(‘utf-8‘) ---> b‘ABC‘
                                                                              接收方: b‘ABC‘.decode(‘utf-8‘) ---> ‘ABC‘

                                                                              9. format: 格式化
                                                                              1) %: 传递基本数据类型
                                                                              %d int, %f float, %s str
                                                                              e.g. ‘hi, %s, you have %.2f dollars‘ % (‘Chandler‘, 18000.509)

                                                                              2) format: 不光可?#28304;?#36882;基本数据类型, 还可?#28304;?#36882;对象
                                                                              e.g. ‘hi, {0}, you have {1:.2f} dollars‘.format(‘xzq‘, 18000.509)
                                                                              e.g. s = Student(‘xzq‘,24)
                                                                              ‘I am {0.name}, {0.age} years old‘.format(s)

                                                                              10. 判断字符串: 返回True/False
                                                                              1) s.startwith(‘a‘,i,j) # ‘s‘是否以‘a‘开头, 可设置检索区间[i,j)
                                                                              2) s.endswith(‘a‘,i,j) # ‘s‘是否以‘a‘结尾, 可设置检索区间[i,j)
                                                                              3) s.isdigit() # 仅有数字
                                                                              4) s.isalnum() # 数字和字母
                                                                              5) s.isalpha() # 特殊字符和字母
                                                                              6) s.isidentifier() # 标识符
                                                                              7) s.isspace() # 空格

                                                                              11. 大小写转化:
                                                                              1) s.upper() # 每个字母大写
                                                                              2) s.lower() # 每个字母小写
                                                                              3) s.capitalize() # 首字母大写
                                                                              4) s.swapcase() # 大小写转换

                                                                              12. 字符串拼接: 会产生临时变量
                                                                              ‘str1‘ + ‘str2‘
                                                                              ‘str‘*5
                                                                              ‘‘‘ # Str: 正则表达式, reModules.py

                                                                              ‘‘‘
                                                                              List: 1. 定义: l = [value, ] # value可以是?#25105;?#30340;数据类型: num,str,bool,list,tuple,dict,obj
                                                                              2. 操作:
                                                                              get: a = l[i] # i0开始

                                                                              add: l.append(value) # 尾插
                                                                              l.extend(iterable) # 合并尾插
                                                                              l.insert(i,value) # 指定位置插, 超过索引则尾插

                                                                              delete: l.remove(value) # 删除指定元素
                                                                              l.pop(i) # 删除指定位?#36855;?#32032;,不指定则默认删除末尾
                                                                              l.clear() # 删除所有元素
                                                                              del l[i] # 删除指定位?#36855;?#32032;, 不指定则删除整个list

                                                                              rewrite: l[i] = new_value # 超过所有则报错

                                                                              search: i = l.index(value) # 查元素下标
                                                                              count = l.count(value) # 统计元素个数
                                                                              3. 方法:
                                                                              list(Seq): 1. 将其他Seq(list, tuple, str)转为List
                                                                              2. 拷贝, 生成新的List对象, 属于深拷贝
                                                                              l1 = [1,2,3]
                                                                              l2 = list(l1)

                                                                              ** 拷贝的方式:
                                                                              1. 按对象引用: l1 = [1,2,3], l2 = l1
                                                                              2. 浅拷贝, 不拷贝内部对象: l2 = l1.copy()
                                                                              3. 深拷贝: l2 = copy.deepcopy(l1)
                                                                              l2 = list(l1)
                                                                              l2 = l1[:]
                                                                              ‘‘‘ # List

                                                                              ‘‘‘
                                                                              Tuple: 不可变类型(hashable), 其他与List类似
                                                                              1. 定义: t = (value, ) # value?#37096;?#20197;是?#25105;?#25968;据类型
                                                                              2. 操作: 只有get: a = t[i]
                                                                              3. 方法: tuple(Seq): 1.转化
                                                                              2.数据拷贝
                                                                              ‘‘‘ # Tuple: 只读的List

                                                                              ‘‘‘
                                                                              Dict: 1. 定义:
                                                                              d1 = {k1:v1, k2:v2,...} # k为不可变数据类型(hashable), num, str, tuple, v可以是?#25105;?#25968;据类型
                                                                              d2 = dict(**kwargs)
                                                                              d3 = dict([(k1,v1),(k2,v2),...])
                                                                              2. 操作:
                                                                              get: a = d[k] # k不存在会报错
                                                                              a = d.get(k) # k不存在返回None
                                                                              add: d[new_k] = new_v
                                                                              delete: d.pop(k), del d[k]
                                                                              rewrite: d[k] = new_v
                                                                              3. 方法:
                                                                              dict(): 1> 拷贝: dict(Dict)
                                                                              2> 创建: dict(**kwargs), dict([(a,b),])

                                                                              dict.fromkeys(seq,value): 创建dict, seq的每一项为key, value为所有keys?#26576;?#22987;值
                                                                              4. 遍历:
                                                                              for k,v in dict.items():
                                                                              for k in dict.keys():
                                                                              for v in dict.values():
                                                                              ‘‘‘ # Dict

                                                                              ‘‘‘
                                                                              Set: 无重复元素, 无序, 不可遍历, 不可变(hashable)
                                                                              1. 定义:
                                                                              s = set(list/tuple) # 元素去重
                                                                              s = {v1,v2,...} # v只能是num,str,tuple
                                                                              2. 操作: 一般是用来判断数据是否在集合中, 不是用来取值的
                                                                              add: s.add(v)
                                                                              delete: s.remove(v) # 删除指定元素
                                                                              a = s.pop() # 弹出首元素,默认顺序为tuple,str,num
                                                                              交集: s1 & s2
                                                                              并集: s1 | s2
                                                                              差集: s1 - s2 # s1s2没有的元素
                                                                              ‘‘‘ # Set

                                                                              ‘‘‘
                                                                              其他共有操作:
                                                                              in, not in, len()

                                                                              == & is: == 调用__eq__()方法, 比较两个对象内容是否相同
                                                                              is 比较两个对象是否完全相同, 内存地址也相同

                                                                              and, or:
                                                                              1. a and b # and为连通型, a,b都要判断
                                                                              2. a or b # or为截断型, a为真则不需要判断b

                                                                              三元表达式: a if condition else b # 条件成立为a, 不成立为b
                                                                              ‘‘‘ # List, Tuple, Dict, Set基本操作

                                                                              # 下一章: AdvanceFeatures.py

                                                                              python基本知识(二):数据类型

                                                                              标签:传递   数字   encoding   拷贝   ...   ide   instance   长度   rewrite   

                                                                              原文地址:https://www.cnblogs.com/lancelotxly/p/10837762.html

                                                                              (0)
                                                                              (0)
                                                                                 
                                                                              举报
                                                                              评论 一句话评论(0
                                                                              0条  
                                                                              登录后才能评论!
                                                                              ? 2014 mamicode.com 版权所有 京ICP备13008772号-2
                                                                              迷上了代码!
                                                                              宁夏11选5开奖查询