python列表输出该序列之和 python输出数字序列

转载

风之谷启航 2023-05-26 09:56:09

文章标签 python中用于生成数字序列的函数字符串元组 bc 文章分类 Python 后端开发

Pythonanddjango(四)

前面的内容：

python and Django(一)准备工作

python and Django(二)走马观花识python

python and Django(三)下马看花赏python-python中的对象

从这篇起开始详细介绍python中的类型：数字、序列(字符串、列表和元组)、映射和集合类型，本篇介绍数字和序列。

数字类型

含义

数字类型是不可更改类型，也就是说变更数字的值会生成新的对象。

更改

下面是一个修改和删除数字类型的例子。

>>> a=1>>> id(a)3629968>>> a=2>>> id(a)3629956>>> del a

>>> id(a)

Traceback (most recent call last):

File"", line1,in

NameError: name'a'isnot defined

>>>

种类

Python中的数字类型：整型、长整型、布尔型、双精度浮点型、十进制浮点型和复数。

1)整型

a)布尔类型：只有两个值的整型。

>>> a=True

>>>int(a)1>>> a=False

>>>int(a)0>>>

>>>bool(1)

True

>>>bool(True)

True

>>>bool('1')

True

>>>bool('0')

True

>>>bool(0)

False

>>>bool('')

False

>>>bool([])

False

>>> a=1>>> b=a<2>>> b

True

>>> True,False=False,True

>>>bool(True)

False

>>>bool(False)

True

b)整型和长整型

Python 2.2以后可以认为整型和长整型是一回事。

>>>10000**8100000000000000000000000000000000L>>>10**8100000000>>>

2)双精度浮点数

类似C#中的double。

3)复数

复数由实数部分和虚数部分构成：real+imagj。

负数属性：

num.real该复数的实部

num num.imag该复数的虚部

num.conjugate()返回该复数的共轭复数

>>> a=1+3j

>>> b=1+3j

>>> id(a)19911528>>> id(b)19911600>>> a.real1.0>>> a.imag3.0>>> a.conjugate

4)十进制浮点数

Decimal

>>> fromdecimalimport Decimal

>>> Decimal("0.1")*Decimal("3.1415926")

Decimal("0.31415926")

运算符

1)混合模式运算符

Python支持不同的数字类型相加。

>>>20+3.569823.569800000000001

2)标准类型运算

>>> a=1.2>>> b=1.20>>> a==b

True

>>> a>b

False

>>> b

False

>>> a>=b

True

>>> a<=b

True

>>> (a==b) or(a>=b)

True

3)算术运算符

+，－，*，/，%，**，//

>>>7.3/71.0428571428571429>>>7.3//71.0>>>4**364>>>

4)位运算符

位运算只支持整数。

取反(~)，按位与(&),或(|)及异或(^)及左移(<>)。

>>>4**364>>>20&350>>>30&4512>>>30|4563>>>30<<2120>>>30<<2120>>> ~30-31>>>30^4551>>>

内建函数

1)type，str，type上篇介绍过。

2)对应于数字类型的函数。

int()、float()、long()、complex()、bool()

>>int(3.1415926)3>>>long(3.1415926)3L>>>float(3.1415926)3.1415926000000001>>> complex(3.1415926)

(3.1415926000000001+0j)

>>>bool(3.1415926)

True

>>>bool(-3.1415926)

True

>>>bool(0)

False

>>>

3)功能函数

abs()：求绝对值；

coerce()：返回一个包含类型转换完毕的两个数值元素的元组。

divmod()：返回一个包含商和余数的元组。

pow()：指数运算。

两个参数时类似于**；

pow()还接受第三个可选的参数，一个余数参数。如果有这个参数的，pow()先进行指数运算，然后将运算结果和第三个参数进行取余运算。

round()：对浮点数进行四舍五入运算。

>>> abs(-1)1>>> coerce(1,13L)

(1L,13L)

>>> divmod(10,3)

(3,1)

>>> divmod(10.21,3.58)

(2.0,3.0500000000000007)

>>> pow(4,3)64>>>4**364>>> pow(4,3,5)4>>> round(3.1415926)3.0>>> round(3.78)4.0>>>

int()、math.floor()和round的区别：

函数int()直接截去小数部分。(返回值为整数)

函数floor()得到最接近原数但小于原数的整数。(返回值为浮点数)

函数round()得到最接近原数的整数。(返回值为浮点数)

>>>fornin(0.2,0.7,1.2,1.7,-0.2,-0.7,-1.2,-1.7):

print'int('+str(n)+'):'printint(n)

print'floor('+str(n)+'):'print math.floor(n)

print'round('+str(n)+'):'print round(n)int(0.2):0floor(0.2):0.0round(0.2):0.0int(0.7):0floor(0.7):0.0round(0.7):1.0int(1.2):1floor(1.2):1.0round(1.2):1.0int(1.7):1floor(1.7):1.0round(1.7):2.0int(-0.2):0floor(-0.2):

-1.0round(-0.2):0.0int(-0.7):0floor(-0.7):

-1.0round(-0.7):

-1.0int(-1.2):

-1floor(-1.2):

-2.0round(-1.2):

-1.0int(-1.7):

-1floor(-1.7):

-2.0round(-1.7):

-2.0>>>

4)仅用于整数的函数

a)进制转换

oct()：转换成八进制

hex()：转换成十六进制

>>> oct(100)'0144'>>> hex(100)'0x64'>>>

b)ASCII转换

chr()：将数值转换为字符

ord()：将字符转换为数值

>>> chr(89)'Y'>>> ord('a')97>>> ord('A')65>>>

和数字相关模块

decimal

十进制浮点运算类Decimal

array

高效数值数组(字符，整数，浮点数等等)

math/cmath

标准C库数学运算函数。常规数学运算在match模块，

复数运算在cmath模块

operator

数字运算符的函数实现

random

多种伪随机数生成器

序列:字符串、列表和元组

特征

1)有序排列，可以通过下标偏移量访问。

2)可通过切片操作一次得到多个元素。

操作运算符

seq[ind]获得下标为ind的元素

seq[ind1:ind2]获得下标从ind1到ind2间的元素集合

seq * expr序列重复expr次

seq1 + seq2连接序列seq1和seq2

obj in seq判断obj元素是否包含在seq中

obj not in seq判断obj元素是否不包含在seq中

1)访问

>>>'abc'[0]'a'>>> ('a','b','c')[0]'a'>>> ['a','b','c'][0]'a'>>> ('a','b','c')[0:1]

('a',)

>>> ('a','b','c')[0:2]

('a','b')

>>> ['a','b','c'][0:2]

['a','b']

>>>'abc'[0:2]'ab'>>>

2)重复

>>>'abc'*3'abcabcabc'>>> ('a','b','c')*2('a','b','c','a','b','c')

>>> ['a','b','c']*2['a','b','c','a','b','c']

>>>

3)连接

>>>'ab'+'c''abc'>>> ['a']+['b']

['a','b']

4)成员关系运算符in、not in

>>>'a'in'abc'True

>>>'a'in'bcd'False

>>>'a'in('a','b','c')

True

>>>'a'in['a','b','c']

True

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

True

>>>

内建函数

1)类型转换

list(iter)

把可迭代对象转换为列表

str(obj)

把obj对象转换成字符串(对象的字符串表示法)

unicode(obj)

把对象转换成Unicode字符串(使用默认编码)

basestring()

抽象工厂函数,其作用仅仅是为str和unicode函数提供父类，所以不能被

实例化，也不能被调用

tuple(iter)

把一个可迭代对象转换成一个元组对象

2)其他函数

enumerate(iter)、len(seq)、max、min、sort、reversed、sorted、sum、zip。

字符串

Python里面单引号和双引号的作用是相同的。

类型

1)通常意义的字符串---basestring的子类

2)Unicode字符串----basestring的子类

操作

1)上面序列的操作都可用于字符串。

2)字符串特有操作

a)格式化

格式化符号

转换成字符(ASCII码值，或者长度为一的字符串)

优先用repr()函数进行字符串转换

优先用str()函数进行字符串转换

%d / %i

转成有符号十进制数

转成无符号十进制数

转成无符号八进制数

%x/%X

(Unsigned)转成无符号十六进制数(x/X代表转换后的十六进制字符的大小写)

%e/%E

转成科学计数法(e/E控制输出e/E)

%f/%F

转成浮点数(小数部分自然截断)

%g/%G

%e和%f/%E和%F的简写

输出%

>>>"%d,%f"%(32,3.14)'32,3.140000'

b)模板Template

两个属性：

substitute：在key缺少的情况下它会报一个KeyError的异常出来。

safe_substitute：在缺少key时，直接原封不动的把字符串显示出来。

>>> fromstringimport Template
>>> s=Template('hi,Welcome to visit ${site}!it is about ${memo}!')
>>> s.substitute(site='apihi',memo='web api')'hi,Welcome to visit apihi! it is about web api!'>>> s.safe_substitute(site='apihi')'hi,Welcome to visit apihi! it is about ${memo}!'>>> s.substitute(site='apihi')
Traceback (most recent call last):
File"", line1,in
File"D:\Python25\lib\string.py", line170,insubstitutereturnself.pattern.sub(convert, self.template)
File"D:\Python25\lib\string.py", line160,inconvert
val = mapping[named]
KeyError:'memo'>>>

c)原始字符串(r)

不对字符串内容进行解析

>>> print'123\n4'1234>>> print r'123\n4'123\n4

d)Unicode字符串(u)

内建函数

字符串的内建函数非常丰富，通过一个例子看一下：

>>> str='hi,Welcome to visit apihi'>>> str.capitalize()'Hi,welcome to visit apihi'>>> str.center(50)'            hi,Welcome to visit apihi             '>>> str.count('i')5>>> str.find('i')1>>> str.endswith('i')
True
>>> str.index('i',2)15>>>str.replace('i','I')
>>> str.replace('i','I')'hI,Welcome to vIsIt apIhI'

特殊性

1)反斜线+单一字符表示特殊字符

如：\n表示换行

2)三引号

可以跨多行，可以包含特殊字符

>>>'''hi!my nameis\n str'''
'hi!\nmy name is \n str'

3)不变性

>>> s='sbc'>>> id(s)19779744>>> s=s+'d'>>> id(s)19738496>>>

列表

列表是可变的容器。

创建及访问

>>> mylist=[1,'a',1.2]
>>> mylist
[1,'a',1.2]
>>> mylist.append(3.14)
>>> mylist
[1,'a',1.2,3.1400000000000001]
>>> mylist[1]'a'>>> mylist[1:3]
['a',1.2]
>>> del mylist[1]
>>> mylist
[1,1.2,3.1400000000000001]
>>> del mylist
>>> mylist
Traceback (most recent call last):
File"", line1,in
NameError: name'mylist'isnot defined
>>>

操作

1)序列的通用操作

2)列表专用操作没有专门用于列表的操作符

内建函数

1)标准类型函数

>>> list1,list2=[1,'a'],[1,'a']
>>> cmp(list1,list2)0

2)序列函数

>>> mylist=[1,2,3,'a']
>>> len(mylist)4>>> sorted(mylist)
[1,2,3,'a']
3)专用于列表的函数
>>> mylist=range(8)
>>> mylist
[0,1,2,3,4,5,6,7]
>>> mylist.append('a')
>>> mylist
[0,1,2,3,4,5,6,7,'a']
>>> mylist.count
>>> mylist.count(1)1>>> mylist.insert(1,'b')
>>> mylist
[0,'b',1,2,3,4,5,6,7,'a']
>>> mylist.reverse()
>>> mylist
['a',7,6,5,4,3,2,1,'b',0]
>>>

元组

元组是不可变的容器。

创建及访问

>>> mytuple=(1,2,3,4,'a')
>>> mytuple
(1,2,3,4,'a')
>>> tuple('abcdefg')
('a','b','c','d','e','f','g')
>>> mytuple[0]1>>> mytuple[1:4]
(2,3,4)
>>> id(mytuple)19758944>>> mytuple=mytuple+('b','c')
>>> mytuple
(1,2,3,4,'a','b','c')

>>> id(mytuple)19840112>>>
操作
>>> mytuple =(1,2,3)
>>> mytuple *2(1,2,3,1,2,3)
>>>1inmytuple
True
>>>4notinmytuple
True
>>> len(mytuple)3>>> (1,2)==(2,1)
False
>>>
特殊性

1)不可变

>>> mytuple=(1,2,3)
>>> id(mytuple)19773760>>> mytuple+=('a','b')
>>> id(mytuple)19758944>>>
默认元组

1)所有的多对象的，逗号分隔的，没有明确用符号定义。

>>>1,2,3,'a'(1,2,3,'a')
2)所有函数返回的多对象
>>> def f():return1,2,3>>> f()
(1,2,3)
单对象元组
>>> a=('a')
>>> type(a)
>>>
非要创建单对象元组，可以通过下面这种做法：
>>> a=('a',)
>>> type(a)
列表和元组
元组不可变，即不会被篡改。
列表和元组可以相互转换
>>> mytuple=(1,2,3)
>>> mytuple
(1,2,3)
>>> mylist=list(mytuple)
>>> mylist
[1,2,3]
>>> tuple(mylist)
(1,2,3)

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。