python内置类型---第二天笔记

强类型语言

***********两个对象的比较*******************

1,值比较,对象中的数据是否相同 ==

2,身份比较,两个变量名引用的是否为同一对象

3,类型比较,

例子:

*************核心数据类型*****************

数字:int lang float complex bool

字符:str unicode

列表:list

字典:dict

元组:tuple

文件:file

其他类型:集合(set) frozenset 类类型 none

其他文件类工具:pipes fifos sockets

**************类型转换****************

str() repr() format():将非字符型数据转换为字符

int():转为整数

float():

In [1]: s = "My boss is lihong"

list(s):将字串s转为列表

In [2]: l1 = list(s)

In [3]: print l1

[‘M‘, ‘y‘, ‘ ‘, ‘b‘, ‘o‘, ‘s‘, ‘s‘, ‘ ‘, ‘i‘, ‘s‘, ‘ ‘, ‘l‘, ‘i‘, ‘h‘, ‘o‘, ‘n‘, ‘g‘]

tuple(s):将字串s转为元组

In [4]: t1 = tuple(s)

In [5]: print t1

(‘M‘, ‘y‘, ‘ ‘, ‘b‘, ‘o‘, ‘s‘, ‘s‘, ‘ ‘, ‘i‘, ‘s‘, ‘ ‘, ‘l‘, ‘i‘, ‘h‘, ‘o‘, ‘n‘, ‘g‘)

set(s):将字串s转为集合

In [6]: s1 = set(s)

In [7]: print s1

set([‘ ‘, ‘b‘, ‘g‘, ‘i‘, ‘h‘, ‘M‘, ‘l‘, ‘o‘, ‘n‘, ‘s‘, ‘y‘])

frozenset():将字串s转换为不可变集合

dict(d):创建字典,其中d必须是(key,vlue)的元组序列

In [11]: l3 = [(‘a‘,1),(‘b‘,11),(‘c‘,45)]

In [12]: print l3

[(‘a‘, 1), (‘b‘, 11), (‘c‘, 45)]

In [13]: d1 = dict(l3)

In [14]: print d1

{‘a‘: 1, ‘c‘: 45, ‘b‘: 11}

chr():将整数转换为字符

ord():将字符转换为整数值

hex():将整数转换为16进制字串

bin():将整数转换为2进制字符

oct():将整数转换为8进制字符

数字类型以及:

Python的数字字面量:布尔型,整数,浮点型,复数

True:1

False:0

import math

序列类型

字符类型:

字符串字面量:吧文本放入单引号、双引号或三引号(可以是三个单引号或三个双引号)

如果要使用Unicode编码,则再字符之前使用字符U进行标识,如u"tre"

文档字串:模块,类或函数的第一条语句是一个字符的话,该字符串就成为文档字符串,可以用__doc__属性引用

运算符:

索引运算

切片运算

扩展运算

************获取帮助******************

dir(sir) 获取名称列表

help(str.find)

*************列表类型*****************

容器类型:

任意对象的有序集合,通过索引访问其中的元素,可变对象

支持异构,任意嵌套

定义一个列表:

l1 = [] 空列表

l2 = [1,2,3,4,5]

l3 = [1,‘b‘] 异构

l4 = [[1,2],[‘a‘,‘b‘]] 嵌套

支持在原处修改:

修改指定的索引元素,修改指定的分片,删除语句,内置方法

l2[1] = 32

l2[3] = ‘xyz‘ 修改

l2[1:3] 显示元素1和2

l2[1:3] = [] 删除

l2.del(l2[1:]) 删除

In [42]: l2.append(l3)

In [43]: print l2

[1, 32, 3, ‘xyz‘, 5, 77, 106, [1, ‘b‘]]

In [11]: l3.

l3.append   l3.extend   l3.insert   l3.remove   l3.sort

l3.count    l3.index    l3.pop      l3.reverse

In [17]: l1 = [1,2,3]

In [18]: l2 = [‘x‘,‘y‘,‘z‘]

In [19]: l1 + l2 连接两个列表返回一个新列表

Out[19]: [1, 2, 3, ‘x‘, ‘y‘, ‘z‘]

In [20]: l1 * 2 把l1重复两次

Out[20]: [1, 2, 3, 1, 2, 3]

in : 成员关系判断符

not in : 。。。

2 in l1 返回True

range()

复制列表:

l2 = l1 因为列表支持原处修改,所以如果此时修改l1,l2也会跟着修改,这叫浅复制

l3 = l1[:] 此时才是复制一个新的列表赋值给l3,再修改l1,l3不会改变

l5 = copy.deepcopy(l1) 深度复制,也是复制而不是指向同一个地址,如上一样

列表解析: []

**************元组tuple****************

表达式符号:()

容器类型:

任意对象的有序集合,通过索引访问其中的元素,不可变对象,长度固定

支持异构,嵌套

定义:t1 = (1,2,3,4,5,1) 小括号可省略

t1.count(1) 计数

t1.index(3) 返回指定的索引

常见操作:

print t1[1:]

t2 = () 定义空元祖

t3 = ()

+ 可将两个元组合并生成新元组

*

in

not in

*************字典dict*****************

在其他编程语言中又称为关联数组或散列表:

通过键实现元素存取;无序集合;可变类型容器,长度可变,支持异构,支持嵌套

符号{},用逗号分隔,冒号隔开的键值映射表

{}:空字典

In [40]: d1 = {‘x‘:32,‘y‘:[1,2,3,4]}

In [41]: d1[‘y‘][1:]

Out[41]: [2, 3, 4]

In [42]: d1[‘x‘] = 88

In [43]: print d1

{‘y‘: [1, 2, 3, 4], ‘x‘: 88}

字典复制:

d2 = d1.copy() 创建一个与d1相同的字典并赋值给d2

d3 = d1

In [44]: d1.

d1.clear

d1.get         引用一个不存在的键也不会抛出异常

d1.iteritems     返回一个迭代器,i1.next可一个一个的显示,直到耗尽

d1.keys         返回键列表

d1.setdefault

d1.viewitems

d1.copy

d1.has_key   判断键值是否存在

d1.iterkeys

d1.pop         弹出指定(指定键)的键值映射

d1.update       将一个字典合并到当前字典(注意有键相同时)

d1.viewkeys

d1.fromkeys

d1.items       字典拆成元组,每对键值组成一个元组,形成元组列表

d1.itervalues 返回一个迭代器,内容是值

d1.popitem     随机弹出键值映射

d1.values       返回值组成的列表

d1.viewvalues

In [45]: t1,t2 = d1.it

d1.items       d1.iteritems   d1.iterkeys    d1.itervalues

In [45]: t1,t2 = d1.items() 变量解包

In [46]: print t1

(‘y‘, [1, 2, 3, 4])

In [47]: print t2

(‘x‘, 88)

In [48]: m1,m2 = d1

In [49]: print m1

y

In [50]: print m2

x

dict(),定义字典的

************zip******************

In [58]: zip(‘xyz‘,‘123‘,‘abc‘)

Out[58]: [(‘x‘, ‘1‘, ‘a‘), (‘y‘, ‘2‘, ‘b‘), (‘z‘, ‘3‘, ‘c‘)]

In [60]: dict(zip(‘xyz‘,‘123‘)) 构造字典

Out[60]: {‘x‘: ‘1‘, ‘y‘: ‘2‘, ‘z‘: ‘3‘}

时间: 2024-10-16 15:24:04

python内置类型---第二天笔记的相关文章

python内置类型详细解释

文章编写借鉴于内置类型 - Python 3.7.3 文档,主要用于自己学习和记录 python主要内置类型包括数字.序列.映射.类.实例和异常 有些多项集类是可变的.它们用于添加.移除或重排其成员的方法,将原地执行,并不返回特定的项,绝对不会返回多项集实例自身而是返回 None. 实际上所有对象都可以被比较.检测逻辑值,以及转换为字符串(使用 repr() 函数或略有差异的 str() 函数). 后一个函数是在对象由 print() 函数输出时被隐式地调用的. 逻辑值检测 任何对象都可以进行逻

Python——内置类型

Python定义了丰富的数据类型,包括: 数值型:int, float, complex 序列:(iterable) str, unicode, tuple, list, bytearray, buffer, xrange 集合:set, fronzeset 映射:dict 文件:file 布尔值:True.False 和 bool() 函数,其中 bool() 函数将一个值转变成布尔对象 True 或 False . 可调用对象:凡是可以使用 x() 调用 x 的对象 x ,称为可调用的,x

易被忽略的Python内置类型

Python中的内置类型是我们开发中最常见的,很多人都能熟练的使用它们. 然而有一些内置类型确实不那么常见的,或者说往往会被我们忽略,所以这次的主题就是带领大家重新认识这些"不同寻常"的内置类型. (注意:本文基于python3,不会包含任何python2相关内容) frozenset 不可变集合(frozenset)与普通的set一样,只不过它的元素是不可变的,因此诸如add,remove,update等可以添加/删除/改变集合内元素的方法是不存在的,换句话说一旦frozenset建

Python内置类型——dict

Python中, 字典是容器,所以可以使用len()方法统计字典中的键值对的个数: 字典是可迭代的,迭代的依据是字典中的键. in, not in 等运算符判断指定的键是否在字典中: 如果索引一个字典中不存在的键,将会抛出异常KeyError: del d[k]将会删除k对应的键值对,如果d中不存在k,则抛出异常KeyError: 字典的返回迭代器的方法比返回列表的方法要节省内存,因为迭代器更省内存. non-mutating方法 d.copy() 返回一份d的浅拷贝. d.items() 返回

python内置类型:列表,包括 list 和 tuple

列表list 是一种有序的集合 ,假定list的名字为class list的元素个数:len( class) 访问元素: a. 索引从0开始    b. 也可以使用[-1],[-2],[-3] 从后面访问元素 添加元素 a. append方法  , 该方法是默认添加元素到末尾     class.append('adam') b. insert方法, 该方法能把元素添加到指定的索引位置   class.insert (1,'lily') 删除元素 pop方法 pop( ):括号内为空时,默认删除

Python内置类型性能分析

timeit模块 timeit模块可以用来测试一小段Python代码的执行速度. Timer是测量小段代码执行速度的类. class timeit.Timer(stmt='pass', setup='pass', timer=<timer function>) stmt参数是要测试的代码语句(statment): setup参数是运行代码时需要的设置: timer参数是一个定时器函数,与平台有关. Timer对象.timeit(number=1000000) Timer类中测试语句执行速度的对

Python内置类型——set

Python中, 集合是容器,可以使用len()计算集合中元素的个数, 集合中不存在重复的元素: 集合是可迭代的,但迭代时以任意的顺序进行. non-mutating方法 s.copy() 返回集合s的浅拷贝. s.difference(s1) 返回集合s中不在集合s1中的元素的集合,即s-s1. s.intersection(s1) 返回s与s1的交集.即s&s1. s.issubset(s1) 判断s是不是s1的子集. s.issuperset(s1) 判断s是不是s1的超集. s.symm

《python编程》第二章笔记

本章讲了python的系统模块,也就是sys和os模块. 唯一的代码可以用来输出文档内容. 还有一些关于字符串的基本操作.用时再查. 讲了一些文件操作的基本知识,实际用时可以简单的调用就行了.同时介绍了一些不同操作系统命令行操作 os.path是目录相关的工具,简单来说,就是os.path.xxx()可以用来处理目录. shell指的是操作命令行的系统,在有ui的系统中,windows中就是MS-DOC,linux中就是别的. 虽然python可以跨系统,但是有些命令是只能在特定系统下运行的.

【二】python内置类型

1.布尔类型 表示真假的类型(true和false) 数字 0.None,以及元素为空的容器类对象都可视作False,反之为 True. In [1]: bool(0) Out[1]: False In [2]: bool(1) Out[2]: True In [3]: bool(-9) Out[3]: True In [4]: bool(5) Out[4]: True In [5]: bool(None) Out[5]: False In [6]: bool("") Out[6]: