基础之列表和元组,python数据结构

  1. Python的数据类型简要介绍

Python常见数据结构详解,python数据结构

本文详细罗列归结了Python常见数据结构,并附以实例加以印证,相信对读者有分明的参照他事他说加以侦查借鉴价值。

总体来讲Python中常见的数据结构能够统称为容器(container)。而类别(如列表和元组)、映射(如字典)以及汇集(set)是3类首要的器皿。

一、系列(列表、元组和字符串)

队列中的每一个成分都有友好的编号。Python中有6种内建的连串。当中列表和元组是最遍布的品类。其余包涵字符串、Unicode字符串、buffer对象和xrange对象。上面注重介绍下列表、元组和字符串。

1、列表

列表是可变的,那是它有别于于字符串和元组的最珍视的天性,一句话归纳即:列表可以修改,而字符串和元组不能够。

(1)、创建

因而上边包车型客车不二秘籍就可以成立二个列表:

list1=['hello','world']
print list1
list2=[1,2,3]
print list2

基础之列表和元组,python数据结构。输出:

['hello', 'world']
[1, 2, 3]

能够看出,那中创建格局要命类似于javascript中的数组。

(2)、list函数

透过list函数(其实list是壹连串型而不是函数)对字符串创设列表非常有效:

list3=list("hello")
print list3

输出:

['h', 'e', 'l', 'l', 'o']

2、元组

元组与列表同样,也是1种队列,唯一分化的是元组不能够被涂改(字符串其实也是有这种特征)。

(1)、创建

t1=1,2,3
t2="jeffreyzhao","cnblogs"
t3=(1,2,3,4)
t4=()
t5=(1,)
print t1,t2,t3,t4,t5

输出:

(1, 2, 3) ('jeffreyzhao', 'cnblogs') (1, 2, 3, 4) () (1,)

从地点我们得以深入分析得出:

a、逗号分隔一些值,元组自动创造达成;

b、元组超越二分之一时候是经过圆括号括起来的;

c、空元组能够用未有包括内容的圆括号来代表;

d、只含八个值的元组,必须加个逗号(,);

(2)、tuple函数

tuple函数和体系的list函数大致同样:以1个队列(注意是系列)作为参数并把它转换为元组。假若参数即使元组,那么该参数就能原样再次来到:

t1=tuple([1,2,3])
t2=tuple("jeff")
t3=tuple((1,2,3))
print t1
print t2
print t3
t4=tuple(123)
print t45

输出:

(1, 2, 3)
('j', 'e', 'f', 'f')
(1, 2, 3)

Traceback (most recent call last):
  File “F:\Python\test.py”, line 7, in <module>
    t4=tuple(123)
TypeError: ‘int’ object is not iterable

3、字符串

(1)创建

str1='Hello world'
print str1
print str1[0]
for c in str1:
  print c

输出:

Hello world
H
H
e
l
l
o

w
o
r
l
d

(2)格式化

字符串格式化使用字符串格式化操作符即百分号%来促成。

str1='Hello,%s' % 'world.'
print str1

格式化操作符的右操作数能够是别的事物,倘诺是元组可能映射类型(如字典),那么字符串格式化将会迥然不一致。

strs=('Hello','world') #元组
str1='%s,%s' % strs
print str1
d={'h':'Hello','w':'World'} #字典
str1='%(h)s,%(w)s' % d
print str1

输出:

Hello,world
Hello,World

留意:假如急需转移的元组作为转变表达式的1局地存在,那么必须将它用圆括号括起来:

str1='%s,%s' % 'Hello','world'
print str1

输出:

Traceback (most recent call last):
 File "F:\Python\test.py", line 2, in <module>
  str1='%s,%s' % 'Hello','world'
TypeError: not enough arguments for format string

假定供给输出%这些特殊字符,毫无疑问,我们会想到转义,但是Python中国科学院学的管理形式如下:

str1='%s%%' % 100
print str1

输出:

100%

对数字进行格式化管理,平时要求调整输出的上涨的幅度和精度:

from math import pi
str1='%.2f' % pi #精度2
print str1
str1='%10f' % pi #字段宽10
print str1
str1='%10.2f' % pi #字段宽10,精度2
print str1

输出:

3.14
 3.141593
   3.14

字符串格式化还含有众多别样拉长的转移类型,可参照官方文书档案。

Python中在string模块还提供其它一种格式化值的章程:模板字符串。它的工作办法接近于广大UNIX
Shell里的变量替换,如下所示:

from string import Template
str1=Template('$x,$y!')
str1=str1.substitute(x='Hello',y='world')
print str1

输出:

Hello,world!

若是替换字段是单词的一有个别,那么参数名称就务须用括号括起来,从而准确指明结尾:

from string import Template
str1=Template('Hello,w${x}d!')
str1=str1.substitute(x='orl')
print str1

输出:

Hello,world!

如要输出$符,能够行使$$输出:

from string import Template
str1=Template('$x$$')
str1=str1.substitute(x='100')
print str1

输出:

100$

而外入眼字参数之外,模板字符串还是能使用字典变量提供键值对拓展格式化:

from string import Template
d={'h':'Hello','w':'world'}
str1=Template('$h,$w!')
str1=str1.substitute(d)
print str1

输出:

Hello,world!

除开格式化之外,Python字符串还停放了大多实用方法,可参照他事他说加以考查官方文书档案,这里不再列举。

四、通用系列操作(方法)

从列表、元组以及字符串能够“抽象”出游列的壹对公家通用方法(不是你想像中的CRUD),那几个操作包罗:索引(indexing)、分片(sliceing)、加(adding)、乘(multiplying)以及检查有个别成分是还是不是属于连串的积极分子。除外,还有划算体系长度、最大非常小元素等内置函数。

(1)索引

str1='Hello'
nums=[1,2,3,4]
t1=(123,234,345)
print str1[0]
print nums[1]
print t1[2]

输出

H
2
345

目录从0(从左向右)初始,全体系列可通过这种措施进行索引。神奇的是,索引能够从最终一个岗位(从右向左)开头,编号是-一:

str1='Hello'
nums=[1,2,3,4]
t1=(123,234,345)
print str1[-1]
print nums[-2]
print t1[-3]

输出:

o
3
123

(2)分片

分片操作用来拜会必将限制内的因素。分片通过冒号相隔的三个索引来实现:

nums=range(10)
print nums
print nums[1:5]
print nums[6:10]
print nums[1:]
print nums[-3:-1]
print nums[-3:] #包括序列结尾的元素,置空最后一个索引
print nums[:] #复制整个序列

输出:

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

差别的宽窄,有分化的输出:

nums=range(10)
print nums
print nums[0:10] #默认步长为1 等价于nums[1:5:1]
print nums[0:10:2] #步长为2
print nums[0:10:3] #步长为3

##print nums[0:10:0] #步长为0
print nums[0:10:-2] #步长为-2

输出:

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

(三)类别相加

str1='Hello'
str2=' world'
print str1+str2
num1=[1,2,3]
num2=[2,3,4]
print num1+num2
print str1+num1

输出:

Hello world
[1, 2, 3, 2, 3, 4]

Traceback (most recent call last):
  File “F:\Python\test.py”, line 7, in <module>
    print str1+num1
TypeError: cannot concatenate ‘str’ and ‘list’ objects

(4)乘法

print [None]*10
str1='Hello'
print str1*2
num1=[1,2]
print num1*2
print str1*num1

输出:

[None, None, None, None, None, None, None, None, None, None]

HelloHello
[1, 2, 1, 2]

Traceback (most recent call last):
  File “F:\Python\test.py”, line 5, in <module>
    print str1*num1
TypeError: can’t multiply sequence by non-int of type ‘list’

(5)成员身份

in运算符会用来检查一个对象是还是不是为某些连串(可能别的项目)的成员(即成分):

str1='Hello'
print 'h' in str1 
print 'H' in str1
num1=[1,2]
print 1 in num1

输出:

False
True
True

(六)长度、最大最小值

因而内建函数len、max和min可以回到类别中所包蕴成分的多寡、最大和微小成分。

str1='Hello'
print len(str1) 
print max(str1)
print min(str1)
num1=[1,2,1,4,123]
print len(num1) 
print max(num1)
print min(num1)

输出:

5
o
H
5
123
1

二、映射(字典)

炫丽中的每一种成分都有多个名字,如您所知,那么些名字专门的工作的名为键。字典(也叫散列表)是Python中唯1内建的投射类型。

1、键类型

字典的键可以是数字、字符串大概是元组,键必须唯壹。在Python中,数字、字符串和元组都被规划成不足变类型,而普及的列表以及集聚(set)都以可变的,所以列表和聚众不能够当做字典的键。键可感到其余不可变类型,那正是Python中的字典最精锐的地点。

list1=["hello,world"]
set1=set([123])
d={}
d[1]=1
print d
d[list1]="Hello world."
d[set1]=123
print d

输出:

{1: 1}

Traceback (most recent call last):
  File “F:\Python\test.py”, line 6, in <module>
    d[list1]=”Hello world.”
TypeError: unhashable type: ‘list’

贰、自动抬高

就算键在字典中并不设有,也可以为它分配1个值,那样字典就可以创立新的项。

三、成员身份

表达式item in
d(d为字典)查找的是键(containskey),而不是值(containsvalue)。

Python字典庞大之处还蕴涵内置了诸多常用操作方法,可参照官方文书档案,这里不再列举。

考虑:依照大家利用强类型语言的阅历,举个例子C#和Java,我们断定会问Python中的字典是线程安全的吧?

三、集合

聚焦(Set)在Python 2.叁引进,日常使用较新版Python可直接创设,如下所示:

strs=set(['jeff','wong','cnblogs'])
nums=set(range(10))

看上去,集合就是由类别(或许别的可迭代的靶子)塑造的。集合的多少个不能缺少特征和措施如下:

壹、别本是被忽视的

集结首要用以检查成员身份,由此别本是被忽略的,如下示例所示,输出的汇集内容是如出一辙的。

set1=set([0,1,2,3,0,1,2,3,4,5])
print set1

set2=set([0,1,2,3,4,5])
print set2

输出如下:

set([0, 1, 2, 3, 4, 5])
set([0, 1, 2, 3, 4, 5])

2、集合成分的种种是随意的

那或多或少和字典特别像,能够总结精通集结为未有value的字典。

strs=set(['jeff','wong','cnblogs'])
print strs

输出如下:

set(['wong', 'cnblogs', 'jeff'])

三、会集常用方法

a、交集union

set1=set([1,2,3])
set2=set([2,3,4])
set3=set1.union(set2)
print set1
print set2
print set3

输出:

set([1, 2, 3])
set([2, 3, 4])
set([1, 2, 3, 4])

union操作重返两个聚众的并集,不改造原来集结。使用按位与(O福特Explorer)运算符“|”能够博得同样的结果:

set1=set([1,2,3])
set2=set([2,3,4])
set3=set1|set2
print set1
print set2
print set3

出口和方面union操作如出一辙的结果。

其他大规模操作包含&(交集),<=,>=,-,copy()等等,这里不再列举。

set1=set([1,2,3])
set2=set([2,3,4])
set3=set1&set2
print set1
print set2
print set3
print set3.issubset(set1)
set4=set1.copy()
print set4
print set4 is set1

出口如下:

set([1, 2, 3])
set([2, 3, 4])
set([2, 3])
True
set([1, 2, 3])
False

b、add和remove

和种类增多和移除的方法丰裕周围,可参照官方文书档案:

set1=set([1])
print set1
set1.add(2)
print set1
set1.remove(2)
print set1
print set1
print 29 in set1
set1.remove(29) #移除不存在的项

输出:

set([1])
set([1, 2])
set([1])
set([1])
False

Traceback (most recent call last):
  File “F:\Python\test.py”, line 9, in <module>
    set1.remove(29) #移除不存在的项
KeyError: 29

4、frozenset

集结是可变的,所以不可能用做字典的键。集合本身只好分包不可变值,所以也就不可能包罗其余会集:

set1=set([1])
set2=set([2])
set1.add(set2)

出口如下:

Traceback (most recent call last):
  File “F:\Python\test.py”, line 3, in <module>
    set1.add(set2)
TypeError: unhashable type: ‘set’

可以采纳frozenset类型用于代表不可变(可散列)的晤面:

set1=set([1])
set2=set([2])
set1.add(frozenset(set2))
print set1

输出:

set([1, frozenset([2])])

补给内容:

Python三为主数据类型(5),python三数据类型

Python中的变量无需申明,各类变量在运用前都必须赋值,变量赋值未来该变量才会被创建。

在Python中变量就是变量,它从不项目,大家所说的”类型”是变量所指的内部存款和储蓄器中指标的类别。

等号(=)用来给变量赋值。

等号(=)运算符左侧是二个变量名,等号(=)运算符左边是积累在变量中的值。举个例子:

1 #!/usr/bin/python3
2  
3 counter = 100          # 整型变量
4 miles   = 1000.0       # 浮点型变量
5 name    = "runoob"     # 字符串
6  
7 print (counter)
8 print (miles)
9 print (name)

实践以上程序会输出如下结果:

1 100
2 1000.0
3 runoob

数据结构是以某种方式(如通过号码)组合起来的多少成分(如数、字符以至其余数据结构)集合。在Python中,最中央的数据结构为种类(sequence)。
Python内置了四种行列,如列表,元组,字符串(由字符组成的队列)

Python数据结构怎举行内建详解

Python数据结构一.
列表list:变量赋值方式:shoplist=[‘apple’,’mango’,’carrot’,’banana’]贰.
元组array:变量赋值方式:zoo=(‘wolf’,‘elephant’,’penguin’)3.
字典dict:变量赋值格局:d={key一:value1,key二:value二}四.
队列:列表、元组和字符串都以体系(一)
索引操作符:获得列表/元组中的二个因素或字符串的的某部字符(贰)
切块操作符:获得系列的二个切成块,接二连三的成分/字符(叁)
eg:name=’swaroop’print‘characters0is’,name[0]#’s’索引操作符,类似C#print‘characters1to3is’,name[1:3]‘wa’
切成块操作符,类似C#
中的Substring方法其实Python包括的剧情还广大众多,如Python和历史观的解释型脚本语言不一致,它在第三次推行时会编写翻译成字节码,其后实践就直接运营字
节码了,那个.NET的DL奥迪Q5有一些类似源码天空,和Java的虚拟机也近乎,综上可得是将代码转化成更就好像机器代码的措施,那样能够提升质量。
 

join:

Python join() 方法用于将种类中的成分以内定的字符连接生成多少个新的字符串。

str.join(sequence)

s='*'
s1='AABCD'
print(s .join(s1))

A*A*B*C*D

多少个变量赋值

Python允许你还要为多个变量赋值。比如:

1 a = b = c = 1

上述实例,创制多少个整型对象,值为壹,多个变量被分配到均等的内部存款和储蓄器空间上。

您也得以为多少个对象内定多个变量。比方:

1 a, b, c = 1, 2, "runoob"

如上实例,五个整型对象 一 和 二 的分红给变量 a 和 b,字符串对象 “runoob”
分配给变量 c。

Python支持一种数据结构的基本概念,名称叫容器(container)。容器基本上就是可含蓄别的对象的对象。三种重大的器皿是系列(列表和元组)和照耀(字典)。

Python 数据结构

s[i:j:k] slice of s from i to j with step k
参谋资料:docs.python.org/…xrange
 

本文详细罗列总结了Python常见数据结构,并附以实例加以印证,相信对读者有自然的参照借鉴价值。…

列表:list

列表是python中的基础数据类型之一,别的语言中也可以有周边于列表的数据类型,例如js中叫数组,他是以[]括起来,每种成分以逗号隔断,而且她当中可以存放各样数据类型举个例子:

li =
[‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

列表比较于字符串,不唯有能够积攒不一样的数据类型,而且能够储存大批量多少,三十几个人python的范围是
53687091贰 个成分,陆15位python的界定是 115292150460684697九个因素。而且列表是稳步的,有索引值,可切成丝,方便取值。

专门的学问数据类型

Python三 中有三个正规的数据类型:

  • Number(数字)
  • String(字符串)
  • List(列表)
  • Tuple(元组)
  • Sets(集合)
  • Dictionary(字典)

在连串中,每种成分都有编号。在光彩夺目中,每一种成分都著名称(也叫键)。有一种既不是种类也不是绚烂的容器,它即是集聚(set)。

增:

澳门葡京备用网址 1澳门葡京备用网址 2

li = [1,'a','b',2,3,'a']
# li.insert(0,55) #按照索引去增加
# print(li)
#
# li.append('aaa') #增加到最后
# li.append([1,2,3]) #增加到最后
# print(li)
#
# li.extend(['q,a,w']) #迭代的去增
# li.extend(['q,a,w','aaa'])
# li.extend('a')
# li.extend('abc')
# li.extend('a,b,c')
# print(li)

View Code

1,Number(数字)

Python3 支持 int、float、bool、complex(复数)

Python 三里,只有一种整数类型 int,表示为长整型,未有 python2 中的 Long。

注意:在 Python② 中是不曾布尔型的,它用数字 0 表示 False,用 一 表示
True。到 Python叁 中,把 True 和 False 定义成首要字了,但它们的值依然 壹和 0,它们得以和数字相加。

像大多数言语 同样,数值类型的赋值和测算都是很直观的。

嵌入的 type() 函数能够用来询问变量所指的对象类型。

1 >>> a, b, c, d = 20, 5.5, True, 4+3j
2 >>> print(type(a), type(b), type(c), type(d))
3 <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

除此以外还足以用 isinstance 来判别:

1 >>>a = 111
2 >>> isinstance(a, int)
3 True
4 >>>

isinstance 和 type 的分别在于:

澳门葡京备用网址 3

 1 class A:
 2     pass
 3 
 4 class B(A):
 5     pass
 6 
 7 isinstance(A(), A)  # returns True
 8 type(A()) == A      # returns True
 9 isinstance(B(), A)    # returns True
10 type(B()) == A        # returns False

View Code

有别于正是:

  • type()不会感觉子类是1种父类类型。
  • isinstance()会以为子类是壹种父类类型。

当您钦命三个值时,Number 对象就能被成立:

1 var1 = 1
2 var2 = 10

你也足以动用del语句删除一些目标引用。

del语句的语法是:

1 del var1[,var2[,var3[....,varN]]]]

您能够因此接纳del语句删除单个或七个对象。譬如:

1 del var
2 del var_a, var_b

  澳门葡京备用网址 4澳门葡京备用网址 5

删:

# l1 = li.pop(1) #按照位置去删除,有返回值
# print(l1)

# del li[1:3] #按照位置去删除,也可切片删除没有返回值。
# print(li)

# li.remove('a') #按照元素去删除
# print(li)

# li.clear() #清空列表

#del 成效一 刨除列表

# del l1

# print(l1)

#成效二 能够遵照切块,根据索引去删除

# del l1[0]

# print(l1)

# del l1[0:3]

# print(l1)

# del l1[1::2]

# print(l1)

(1)int(整型)

Python能够拍卖大4大小的整数,当然包括负整数,在先后中的表示方法和数学上的写法一模2样,比如:1100-80800,等等

Computer由于应用二进制,所以,不经常候用十陆进制表示整数相比便于,十6进制用0x前缀和0-9,a-f表示,例如:0xff000xa5b4c3d2,等等

在三拾人机器上,整数的位数为3十四位,取值范围为-二**31~2**31-1,即-2147483648~2147483647

在61个人系统上,整数的位数为陆12位,取值范围为-二**63~2**63-1,即-9223372036854775808~9223372036854775807

例:

1 >>> a,b=1,3
2 >>> a+b

 

改:

#按照索引去改
# l1[0] = '男神'
# print(l1)

#按照切片去改
# l1[0:2] = ['屌丝','alex']
# l1[0:2] = '化工哥,树脂'
# print(l1)

(2)float(浮点型)

浮点数也便是小数,之所以称之为浮点数,是因为依据科学记数法表示时,3个浮点数的小数点地点是可变的,举例,一.二3x拾九和1二.3x拾8是截然相等的。

浮点数能够用数学写法,如1.233.14-9.01,等等。但是对于十分大或十分的小的浮点数,就亟须用科学计数法表示,把10用e代替,壹.2三x10九就

1.23e9,或者12.3e8,0.00001贰得以写成1.2e-5,等等。

平头和浮点数在Computer内部存款和储蓄的措施是见仁见智的,整数运算永久是规范的(除法难道也是标准的?是的!),而浮点数运算则大概会有四舍5入的固有误差。

列表和元组的第1不相同在于,列表是能够修改的,而元组无法

查:

#查 按切片,按索引去查
# l1[0]
# l1[0:3]

#for 循环查
# for i in l1:
#     print(i)
l2 = [1,3,6,8,7,4,2,9,10]
# len 长度
# print(len(l1))
#count 出现次数
# ret = l1.count(True)
# print(ret)
#index 通过元素找索引
# print(l1.index('taibai'))
#sort 从小到大
# l2.sort()
# print(l2)
# #sort(reverse)  从大到小
# l2.sort(reverse=True)
# print(l2)

(3)bool(布尔型)

在Python中,能够一贯用TrueFalse表示布尔值(请留意分寸写),也得以通过布尔运算总结出来:

澳门葡京备用网址 6

 1 >>> True
 2 True
 3 >>> False
 4 False
 5 >>> 3 > 2
 6 True
 7 >>> 3 > 5
 8 False
 9 >>> True+1
10 2
11 >>> False+1
12 1
13 >>> True==1
14 True
15 >>> True==2
16 False
17 >>> False==1
18 False
19 >>> False==0
20 True

View Code

布尔值能够用andornot运算。

and运算是与运算,唯有具有都为Trueand运算结果才是True

澳门葡京备用网址 7

1 >>> True and True
2 True
3 >>> True and False
4 False
5 >>> False and False
6 False
7 >>> 5 > 3 and 3 > 1
8 True

View Code

or澳门葡京备用网址,运算是或运算,只要在这之中有二个为Trueor运算结果正是True

澳门葡京备用网址 8

1 >>> True or True
2 True
3 >>> True or False
4 True
5 >>> False or False
6 False
7 >>> 5 > 3 or 1 > 3
8 True

View Code

not运算是非运算,它是八个单目运算符,把True变成FalseFalse变成True

澳门葡京备用网址 9

1 >>> not True
2 False
3 >>> not False
4 True
5 >>> not 1 > 2
6 True

View Code

布尔值平日用在基准决断中,举个例子:

澳门葡京备用网址 10

1 if age >= 18:
2     print('adult')
3 else:
4     print('teenager')

View Code

那意味列表适用于要求中途添日币素的情景,而元组适用于出于某种思量需求禁止修改类别的动静。禁止修改类别平常出于技巧上边的思索,与Python的内部职业规律相关,那也是多少内置函数重回元组的彻头彻尾的经过所在。

其它操作:

count(数)(方法总结有个别成分在列表中冒出的次数)。

1 a = ["q","w","q","r","t","y"]
2 print(a.count("q"))

index(方法用于从列表中寻觅有些值第贰个相配项的目录地方)

1 a = ["q","w","r","t","y"]
2 print(a.index("r"))

sort (方法用于在原职分对列表举办排序)。

 reverse (方法将列表中的成分反向存放)。

1 a = [2,1,3,4,5]
2 a.sort()# 他没有返回值,所以只能打印a
3 print(a)
4 a.reverse()#他也没有返回值,所以只能打印a
5 print(a)

(4)complex(复数)

 复数由实数部分和虚数部分构成,能够用a + bj,也许complex(a,b)表示,
复数的实部a和虚部b都以浮点型。

如:3e+26j

在我们编写程序时,差不多在具有情状下都可应用列表来代表元组。据自身当下所知,当元组用作字典键时,不能够用列表来顶替元组(原因是因为字典键差异意修改)

列表的嵌套:

澳门葡京备用网址 11澳门葡京备用网址 12

l1 = ['小新','egon','wusir',[99,'tiabai','ritian',[,2,3]],2]
# a = l1[1].capitalize()
# l1[1] = a
# l1[1] = l1[1].capitalize()
# l1[1] = 'Alex'
# print(l1)
# print(l1[0])
# print(l1[3])
# l = l1[3]
# s = l[1].upper()
# l1[3][1] = s
# l1[3][1] = l1[3][1].upper()
# print(l1)
# l1[3][0] = '100'
# print(l1)
# l1[3][0] = str(l1[3][0] + 1)
# print(l1)

View Code

(5)空值

空值是Python里一个古怪的值,用None表示。None不可能知道为0,因为0是有含义的,而None是叁个特种的空值。

注意:

  • 一、Python能够同时为两个变量赋值,如a, b = 一, 2。
  • 二、几个变量能够通过赋值指向区别类别的目标。
  • 三、数值的除法(/)总是回到三个浮点数,要得到整数使用 // 操作符。
  • 4、在混合计算时,Python会把整型转变到为浮点数。

要素都有号子,即其岗位或索引,当中第③个成分的目录为0,第二个因素的目录为一,就那样类推。在稍微编制程序语言中,从1从头给体系中的成分编号,但从0起初提议相对于队列开始的偏移量。这呈现更自然,同时可回旋到行列末尾,用负索引表示系列末尾元素的职责。

元祖:tuple:

元组被称作只读列表,即数据足以被询问,但不可能被涂改,所以,字符串的切成条操作同样适用于元组。例:(一,二,叁)(”a”,”b”,”c”)

澳门葡京备用网址 13澳门葡京备用网址 14

# tuple
tu = (1,2,'wusir','taibai',[2,3,4,],True)
l = [1,2,True]
# for i in tu:
#     print(i)
# print(tu[2:])

#儿子不能更改,但是孙子有可能更改
# tu1 = (1,2,'wusir',[1,2,3],(2,3,4),'taibai',True)
# tu1[3].pop(1)
# print(tu1)
# tu1[3].append('taibai')
# print(tu1)
# print(len(tu))
# print(tu.count(1))
# print(l.count(1))
# print(tu.index('wusir'))

View Code

数值类型实例

int float complex
10 0.0 3.14j
100 15.20 45.j
-786 -21.9 9.322e-36j
080 32.3+e18 .876j
-0490 -90. -.6545+0J
-0x260 -32.54e100 3e+26J
0x69 70.2-E12 4.53e-7j

Python还援助复数,复数由实数部分和虚数部分构成,可以用a +
bj,可能complex(a,b)表示, 复数的实部a和虚部b都以浮点型

  

range:

python range() 函数可创设叁个平头列表,一般用在 for 循环中。

range(start, stop[, step])
  • start: 计数从 start 早先。私下认可是从 0
    初步。例如range(五)等价于range(0, 5);
  • end: 计数到 end 甘休,但不蕴含 end。举个例子:range(0, 伍) 是[0, 1,
    2, 3, 4]没有5
  • step:步长,默认为1。例如:range(0, 5) 等价于 range(0, 5, 1)

澳门葡京备用网址 15澳门葡京备用网址 16

range当做:范围列表[],列表中的元素是数字,且可控的有效数字范围
一般与for 配合使用
for i in range(1,10):  #[1,2,3,4...9]
    print(i)
for i in range(1,101):  #
    print(i)
for i in range(11):  #
    print(i)
for i in range(1,10,2):  # [1,3,5,7,9]
    print(i)
for i in range(10,0,-1):
    print(i)
for i in range(10,-2,-1):
    print(i)

l1 = [1,2,3,'alex',[2,3,'wusir'],7]
for i in l1:
    if type(i) == list:
        for j in i:
            print(j)
    else:
        print(i)

View Code

 2,String(字符串)

Python中的字符串用单引号(‘)或双引号(“)括起来,同时选拔反斜杠(\)转义特殊字符。

字符串的截取的语法格式如下:

变量[头下标:尾下标]

索引值以 0 为发端值,-一 为从最后的发端地点。

加号 (+) 是字符串的连接符, 星号 (*)
表示复制当前字符串,紧跟的数字为复制的次数。实比如下:

 1 #!/usr/bin/python3
 2  
 3 str = 'Runoob'
 4  
 5 print (str)          # 输出字符串
 6 print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
 7 print (str[0])       # 输出字符串第一个字符
 8 print (str[2:5])     # 输出从第三个开始到第五个的字符
 9 print (str[2:])      # 输出从第三个开始的后的所有字符
10 print (str * 2)      # 输出字符串两次
11 print (str + "TEST") # 连接字符串

试行以上程序会输出如下结果:

1 Runoob
2 Runoo
3 R
4 noo
5 noob
6 RunoobRunoob
7 RunoobTEST

Python
使用反斜杠(\)转义特殊字符,假设您不想让反斜杠发生转义,能够在字符串前边增加三个r,表示原始字符串:

1 >>> print('Ru\noob')
2 Ru
3 oob
4 >>> print(r'Ru\noob')
5 Ru\noob
6 >>> 

另外,反斜杠(\)可以看成续行符,表示下一行是上一行的接二连三。也得以运用 “””…””” 或者 ”’…”’ 跨更加多行。

留意,Python 未有单独的字符类型,贰个字符就是长度为一的字符串。

1 >>>word = 'Python'
2 >>> print(word[0], word[5])
3 P n
4 >>> print(word[-1], word[-6])
5 n P

与 C 字符串不一致的是,Python
字符串不能够被退换。向3个目录地方赋值,譬如word[0] = ‘m’会导致错误。

注意:

  • 一、反斜杠能够用来转义,使用r能够让反斜杠不发生转义。
  • 二、字符串能够用+运算符连接在壹块,用*运算符重复。
  • 三、Python中的字符串有两种索引格局,从左往右以0起初,从右往左以-一早先。
  • 四、Python中的字符串不可能更换。
  1. Python类别之列表:Python新秀军

 字典:

字典是python中头一无二的投射类型,选取键值对(key-value)的款型积攒数据。python对key进行哈希函数运算,依照测算的结果决定value的累积地方,所以字典是九冬存款和储蓄的,且key必须是可哈希的。可哈希代表key必须是不足变类型,如:数字、字符串、元组。

  字典(dictionary)是除列表意外python之中最灵敏的停放数据结构类型。列表是不改变的指标结合,字典是冬日的指标集结。两个之间的分别在于:字典个中的成分是透过键来存取的,而不是由此偏转移存入取。

3,List(列表)

List(列表) 是 Python 中选拔最频繁的数据类型。

列表能够形成大诸多集结类的数据结构完成。列表凉月素的品类能够不1致,它扶助数字,字符串以致能够蕴含列表(所谓嵌套)。

列表是写在方括号([])之间、用逗号分隔断的因素列表。

和字符串同样,列表一样能够被索引和截取,列表被截取后赶回1个饱含所需成分的新列表。

列表截取的语法格式如下:

变量[头下标:尾下标]

索引值以 0 为伊始值,-一 为从最终的发端地点。

加号(+)是列表连接运算符,星号(*)是重新操作。如下实例:

澳门葡京备用网址 17

 1 #!/usr/bin/python3
 2  
 3 list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
 4 tinylist = [123, 'runoob']
 5  
 6 print (list)            # 输出完整列表
 7 print (list[0])         # 输出列表第一个元素
 8 print (list[1:3])       # 从第二个开始输出到第三个元素
 9 print (list[2:])        # 输出从第三个元素开始的所有元素
10 print (tinylist * 2)    # 输出两次列表
11 print (list + tinylist) # 连接列表

View Code

上述实例输出结果:

澳门葡京备用网址 18

1 ['abcd', 786, 2.23, 'runoob', 70.2]
2 abcd
3 [786, 2.23]
4 [2.23, 'runoob', 70.2]
5 [123, 'runoob', 123, 'runoob']
6 ['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

View Code

与Python字符串分歧等的是,列表中的成分是能够变动的:

澳门葡京备用网址 19

1 >>>a = [1, 2, 3, 4, 5, 6]
2 >>> a[0] = 9
3 >>> a[2:5] = [13, 14, 15]
4 >>> a
5 [9, 2, 13, 14, 15, 6]
6 >>> a[2:5] = []   # 将对应的元素值设置为 [] 
7 >>> a
8 [9, 2, 6]

View Code

List内置了有不少方式,比方append()、pop()等等

注意:

  • 一、List写在方括号之间,成分用逗号隔开分离。
  • 二、和字符串同样,list能够被索引和切条。
  • 三、List可以利用+操作符进行拼接。
  • 4、List中的成分是足以变动的。

目录、切块、相加、相乘和分子身份检查适用于具有的队列。其它,
Python还提供了有的置于函数,可用以显明系列的长短以及搜索游列中最大和微小的因素。

增:

增 dic['key'] = value
# 有key 就覆盖,没有key就添加.
# dic['name2'] = '依米'
# print(dic)
# dic['name'] = '王子'
# print(dic)
#setdeafult
#有key不变,没有key才添加.
# dic.setdefault('hobby')
# print(dic)
# dic.setdefault('hobby','开船')
# print(dic)
# dic.setdefault('name','太白')
# print(dic)

4,Tuple(元组)

元组(tuple)与列表类似,不相同之处在于元组的要素不能够修改。元组写在小括号(())里,成分之间用逗号隔开分离。

元组中的成分类型也得以不平等:

澳门葡京备用网址 20

 1 #!/usr/bin/python3
 2  
 3 tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
 4 tinytuple = (123, 'runoob')
 5  
 6 print (tuple)             # 输出完整元组
 7 print (tuple[0])          # 输出元组的第一个元素
 8 print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
 9 print (tuple[2:])         # 输出从第三个元素开始的所有元素
10 print (tinytuple * 2)     # 输出两次元组
11 print (tuple + tinytuple) # 连接元组

View Code

以上实例输出结果:

澳门葡京备用网址 21

1 ('abcd', 786, 2.23, 'runoob', 70.2)
2 abcd
3 (786, 2.23)
4 (2.23, 'runoob', 70.2)
5 (123, 'runoob', 123, 'runoob')
6 ('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

View Code

元组与字符串类似,能够被索引且下标索引从0初始,-壹为从最终初叶的职位。也足以开始展览截取(看上面,这里不再赘述)。

其实,能够把字符串看作1种特别的元组。

澳门葡京备用网址 22

 1 >>>tup = (1, 2, 3, 4, 5, 6)
 2 >>> print(tup[0])
 3 1
 4 >>> print(tup[1:5])
 5 (2, 3, 4, 5)
 6 >>> tup[0] = 11  # 修改元组元素的操作是非法的
 7 Traceback (most recent call last):
 8   File "<stdin>", line 1, in <module>
 9 TypeError: 'tuple' object does not support item assignment
10 >>>

View Code

尽管如此tuple的因素不可更换,但它能够包罗可变的目的,譬喻list列表。

结构包涵 0 个或 1 个要素的元组相比奇特,所以有一对附加的语法规则:

澳门葡京备用网址 23

1 tup1 = ()    # 空元组
2 tup2 = (20,) # 一个元素,需要在元素后添加逗号

View Code

string、list和tuple都属于sequence(序列)。

注意:

  • 壹、与字符串同样,元组的成分不能够修改。
  • 二、元组也足以被索引和切成条,方法1致。
  • 3、注意协会蕴含0或3个成分的元组的出格语法规则。
  • 四、元组也足以行使+操作符实行拼接。

列表是可变的,就可以修改其剧情。别的,列表有过多故意的艺术。

删:

# 删  pop 按key删除,有返回值,
# 并且如果没有此key,可设置返回值.
# ret = dic.pop('sex')
# print(ret)
# ret = dic.pop('sex1','没有此键')
# print(ret)
#清空 clear()
# dic.clear()
# print(dic)
#del 删除字典,删除键值对
# del dic
# print(dic)

# del dic['name']
# print(dic)
#popitem()  随机删除
# ret = dic.popitem()
# print(ret)
# print(dic)

5,Set(集合)

聚焦(set)是三个严节不另行成分的队列。

基本功效是举办成员涉及测试和删除重复元素。

能够选用大括号 { } 只怕 set() 函数创造集结,

专注:制造三个空会集必须用 set() 而不是 { },因为 { } 是用来创制3个空字典。

创设格式:

parame = {value01,value02,...}
或者
set(value)

 1 #!/usr/bin/python3
 2  
 3 student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
 4  
 5 print(student)   # 输出集合,重复的元素被自动去掉
 6  
 7 # 成员测试
 8 if('Rose' in student) :
 9     print('Rose 在集合中')
10 else :
11     print('Rose 不在集合中')
12  
13  
14 # set可以进行集合运算
15 a = set('abracadabra')
16 b = set('alacazam')
17  
18 print(a)
19  
20 print(a - b)     # a和b的差集
21  
22 print(a | b)     # a和b的并集
23  
24 print(a & b)     # a和b的交集
25  
26 print(a ^ b)     # a和b中不同时存在的元素

如上实例输出结果:

1 {'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
2 Rose 在集合中
3 {'b', 'a', 'c', 'r', 'd'}
4 {'b', 'd', 'r'}
5 {'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
6 {'a', 'c'}
7 {'l', 'r', 'z', 'm', 'b', 'd'}

透过列表可以对数据达成最有益的积累、修改等操作。

改:

# 改
# dic['key'] = value
# 有key 就覆盖.
# update 将dic的键值对,覆盖,添加到dic2 中,dic不变
# dic = {"name":"jin","age":18,"sex":"male"}
# dic2 = {"name":"alex","weight":75}
# dic2.update(dic)
# print(dic)
# print(dic2)

6,Dictionary(字典)

字典(dictionary)是Python中另一个十二分有效的嵌入数据类型。

列表是稳步的靶子结合,字典是冬天的靶子集结。

两个之间的差异在于:字典个中的因素是透过键来存取的,而不是透过偏转移存入取。

字典是1种酷炫类型,字典用”{ }”标志,它是二个冬辰的键(key) :
值(value)
对集合。

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

在同贰个字典中,键(key)必须是唯1的

 1 #!/usr/bin/python3
 2  
 3 dict = {}
 4 dict['one'] = "1 - 菜鸟教程"
 5 dict[2]     = "2 - 菜鸟工具"
 6  
 7 tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
 8  
 9  
10 print (dict['one'])       # 输出键为 'one' 的值
11 print (dict[2])           # 输出键为 2 的值
12 print (tinydict)          # 输出完整的字典
13 print (tinydict.keys())   # 输出所有键
14 print (tinydict.values()) # 输出所有值

以上实例输出结果:

1 1 - 菜鸟教程
2 2 - 菜鸟工具
3 {'name': 'runoob', 'site': 'www.runoob.com', 'code': 1}
4 dict_keys(['name', 'site', 'code'])
5 dict_values(['runoob', 'www.runoob.com', 1])

构造函数 dict() 能够平素从键值对队列中创设字典如下:

1 >>>dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
2 {'Taobao': 3, 'Runoob': 1, 'Google': 2}
3  
4 >>> {x: x**2 for x in (2, 4, 6)}
5 {2: 4, 4: 16, 6: 36}
6  
7 >>> dict(Runoob=1, Google=2, Taobao=3)
8 {'Taobao': 3, 'Runoob': 1, 'Google': 2}

其余,字典类型也是有部分内置的函数,比方clear()、keys()、values()等。

注意:

  • 一、字典是1种绚烂类型,它的成分是键值对。
  • 二、字典的入眼字必须为不可变类型,且无法再度。
  • 3、创立空字典使用 { }

列表用中括号括起。

查:

# 查
# print(dic['name'])
# print(dic['name2'])

# print(dic.get('name'))
# print(dic.get('name2'))
# print(dic.get('name2','没有此键值对'))

Python数据类型转换

突发性,我们必要对数据内置的品类进行退换,数据类型的转变,你只必要将数据类型作为函数名就能够。

以下多少个放置的函数能够实行数据类型之间的转移。那个函数重回贰个新的对象,表示转换的值。

函数 描述

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)

将一个整数转换为一个八进制字符串

Python中的变量不需求注脚,每种变量在使用前都必须赋值,变量赋值今后该变量才会被成立。…

  2.1  函数list

字典嵌套和别的用法:

澳门葡京备用网址 24澳门葡京备用网址 25

dic = {
    'name':'金鑫',
    'name_list':[1,2,3,'李杰'],
    1:{
        'python10':['小黑','萌哥'],
       '老男孩':{'name':'oldboy','age':56}
    }
}
#1,[1,2,3,'李杰']追加'wusir'
#2, ['小黑','萌哥'] 小黑 萌哥中间 插入一个花哥
#3, {'name':'oldboy','age':56} 添加一个键值对,hobby:男人
l = [1,2,3]
# print(l.append('wusir'))
# print(l)
# dic['name_list'].append('wusir')
# print(dic)
# l = dic[1]['python10']
# l.insert(1,'花哥')
# print(dic)
# dic1 = dic[1]
# dic2 = dic1['老男孩']
# dic2['hobby'] = '男人'

# dic[1]['老男孩']['hobby'] = 'man'
# print(dic)

View Code

澳门葡京备用网址 26澳门葡京备用网址 27

# a,b = 1,2
# print(a,b)
# a = 1 b = 3 一行代码,让a,b值互换
# a = 1
# b = 3
# a,b = b,a
# print(a,b)
# a,b = ['alex','wusir']
# print(a,b)
# a,b = ('alex','wusir')
# print(a,b)
keys = dic.keys()
# print(keys,type(keys))
# k = list(keys)
# print(k,type(k))
# values = dic.values()
# print(values)
# items = dic.items()
# print(items)
#
# for k in dic:
#     print(k)
# for k in dic.keys():
#     print(k)
# for v in dic.values():
#     print(v)

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

# for k in dic:
#     print(k,dic[k])

View Code

 

 

 

可将字符串转化为列表,可将别的系列(不只有是字符串)作为list的参数。函数list实际上是1个类,也是贰个厂子函数,近来,这种差异不重大。

澳门葡京备用网址 28澳门葡京备用网址 29

>>> list('function')
['f', 'u', 'n', 'c', 't', 'i', 'o', 'n']

View Code

提示:要将字符列表(如前述代码中的字符列表)转变为字符串,可选拔上边的表明式(字符串操作方法):

澳门葡京备用网址 30澳门葡京备用网址 31

>>> test = ['f', 'u', 'n', 'c', 't', 'i', 'o', 'n']
>>> print(''.join(test))
function

View Code

二.2  基本列表操作

2.2.1 索引(indexing)

队列中具备因素都有号子——从0伊始递增。-一是终极2个成分的职分。分化于别的语言,Python未有特地用来表示字符串的类别,因而1个字符正是只含有叁个成分的字符串。

澳门葡京备用网址 32澳门葡京备用网址 33

# 索引操作实例
# Print out a date, given year, month, and day as numbers
months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
# A list with one ending for each number from 1 to 31
endings = ['st', 'nd', 'rd'] + 17 * ['th'] \
           + ['st', 'nd', 'rd'] + 7 * ['th'] \
           + ['st']

year = input('Year: ')
month = input('Month (1-12): ')
day = input('Day (1-31): ')

month_number = int(month)
day_number = int(day)

# Remember to subtract 1 from month and day to get a correct index(The index starts from 0)
month_name = months[month_number-1]
ordinal = day + endings[day_number-1]
print(month_name + ' ' + ordinal + ', ' + year)
执行结果:
Year: 2018
Month (1-12): 3
Day (1-31): 3
March 3rd, 2018

View Code

2.2.2 切片

首先个数字代表切条开端地方(暗许0)

其次个数字代表切成片截至(但不包含)地点(暗中同意位列表长度)
第三个数字代表切成片的肥瘦(暗许一)

澳门葡京备用网址 34澳门葡京备用网址 35

number = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(number[0:10:1])   # 0,1全部可省略
print(number[:])        # print(number[:]) = print(number[:10]) = print(number[:100])
print(number[::2])
print(number[1::2])
print(number[2::3])     # 切片,从第二个元素开始,第一个元素的索引(下标)为0,那么3的索引为2,每隔3位取一个元素
执行结果:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 3, 5, 7, 9]
[2, 4, 6, 8, 10]
[3, 6, 9]

View Code

澳门葡京备用网址 36澳门葡京备用网址 37

names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]
print(names)
print(names[0], names[2])
print(names[1:3])       # 切片,顾头不顾尾!取位置为1~2的字符串
print(names[-1])        # 切片,从左往右数,-4,-3,-2,-1   取最后一个元素
print(names[-2:])       # 切片,取最后两个值
print(names[-3:-1])     # 切片,从左往右数,顾头不顾尾!取倒数第三个和倒数第二个元素
print(names[0:3])       # 切片,0可以省略,取前三个元素
执行结果:
['DJ', 'ZhangYang', 'YanYun', 'WangYa', 'LiLei']
DJ YanYun
['ZhangYang', 'YanYun']
LiLei
['WangYa', 'LiLei']
['YanYun', 'WangYa']
['DJ', 'ZhangYang', 'YanYun']

View Code

2.2.3 追加

澳门葡京备用网址 38澳门葡京备用网址 39

names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]
print(names)
names.append("LiLei")
print(names)
执行结果:
['DJ', 'ZhangYang', 'YanYun', 'WangYa', 'LiLei']
['DJ', 'ZhangYang', 'YanYun', 'WangYa', 'LiLei', 'LiLei']

View Code

2.2.4 插入

澳门葡京备用网址 40澳门葡京备用网址 41

names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]
names.insert(1, "FFF")     # 插入,1——>下标
names.insert(3, "ppp")     # 插入,3——>下标
print(names)
执行结果:
['DJ', 'FFF', 'ZhangYang', 'ppp', 'YanYun', 'WangYa', 'LiLei']

View Code

2.2.5 修改(替换)

澳门葡京备用网址 42澳门葡京备用网址 43

names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]
names[1] = "XXXXX"            # 替换
print(names)
执行结果:
['DJ', 'XXXXX', 'YanYun', 'WangYa', 'LiLei']

View Code

2.2.6 删除

澳门葡京备用网址 44澳门葡京备用网址 45

# delete
names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]
# names.remove("YanYun")
# del names[3]  = names.pop(3)
names.pop()                  # 如果不输入下标,默认删除最后一个
print(names)
执行:
['DJ', 'ZhangYang', 'YanYun', 'WangYa']

View Code

2.2.7 统计

澳门葡京备用网址 46澳门葡京备用网址 47

names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]
print(names.count("ZhangYang"))
执行:
1

View Code

2.2.8 扩展(合并)

澳门葡京备用网址 48澳门葡京备用网址 49

names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]
names2 = ['1', '5', 'FFF', 'DJ']
# 合并,如果不删除names2,仍然存在
names.extend(names2)
del names2
print(names)
执行:
['DJ', 'ZhangYang', 'YanYun', 'WangYa', 'LiLei', '1', '5', 'FFF', 'DJ']

View Code

2.2.9 清空

澳门葡京备用网址 50澳门葡京备用网址 51

>>> names = ["DJ", "ZhangYang", "YanYun", "WangYa", "LiLei"]
>>> print(names.clear())
None

View Code

二.二.10 排序(特殊符号,数字,大写,小写)

澳门葡京备用网址 52澳门葡京备用网址 53

names = ["DJ", "ZhangYang", "zhangYang", "YanYun", "WangYa", "LiLei"]
names.sort()
print(names)
names2 = ['LiLei', '#!WangYa', '4DDD', 'aFFF', 'ZhangYang', 'FFF', 'DJ']
names2.sort()
print(names2)
执行:
['DJ', 'LiLei', 'WangYa', 'YanYun', 'ZhangYang', 'zhangYang']
['#!WangYa', '4DDD', 'DJ', 'FFF', 'LiLei', 'ZhangYang', 'aFFF']

View Code

贰.2.1一 反转排序

澳门葡京备用网址 54澳门葡京备用网址 55

names = ["DJ", "ZhangYang", "zhangYang", "YanYun", "WangYa", "LiLei"]
names.reverse()
print(names)
names2 = ['LiLei', '#!WangYa', '4DDD', 'aFFF', 'ZhangYang', 'FFF', 'DJ']
names2.reverse()
print(names2)
执行:
['LiLei', 'WangYa', 'YanYun', 'zhangYang', 'ZhangYang', 'DJ']
['DJ', 'FFF', 'ZhangYang', 'aFFF', '4DDD', '#!WangYa', 'LiLei']

View Code

2.2.12 浅copy

澳门葡京备用网址 56澳门葡京备用网址 57

import copy
person = ['name', ['saving', 1000]]

p1 = person.copy()    # 浅copy,只复制上一层的子列表,子列表是一个独立的内存指针,是一个内存地址,复制的是内存地址
p2 = person[:]
p3 = list(person)

p1[0] = 'alex'
p2[0] = 'A_Wife'
p1[1][1] = 500

print(p1)
print(p2)
print(p3)

执行:
['alex', ['saving', 500]]
['A_Wife', ['saving', 500]]
['name', ['saving', 500]]

View Code

2.2.13 深copy

澳门葡京备用网址 58澳门葡京备用网址 59

import copy
names = ["DJ", "ZhangYang", "YanYun",['alex', 'Jack'], "WangYa", "LiLei"]
# 浅copy,只复制上一层的子列表,子列表是一个独立的内存指针,是一个内存地址,复制的是内存地址
# names2 = names.copy()
# 深copy,占两份独立的地址空间
names2 = copy.deepcopy(names)
print(names)
print(names2)
names[0] = "帝姬"
names[3][0] = "ALEX"     # 由于指向同一块地址空间,names[3][0] = names2[3][0]
print(names)
print(names2)

执行:
['DJ', 'ZhangYang', 'YanYun', ['alex', 'Jack'], 'WangYa', 'LiLei']
['DJ', 'ZhangYang', 'YanYun', ['alex', 'Jack'], 'WangYa', 'LiLei']
['帝姬', 'ZhangYang', 'YanYun', ['ALEX', 'Jack'], 'WangYa', 'LiLei']
['DJ', 'ZhangYang', 'YanYun', ['alex', 'Jack'], 'WangYa', 'LiLei']

View Code

 

 叁. Python体系之元组:不可修改的队列

元组其实跟列表大约,也是存1组数,只不是它假诺创建,便不可能像列表式的增加和删除改,只好查,切块,所以元组又叫只读列表。

元组用圆括号括起(那是平凡采取的做法)。

3.1 函数tuple

函数tuple的干活原理与list类似:它将3个体系作为参数,并将其更改为元组。假诺参数已经是元组,就原封不动地再次回到它。它一律是工厂函数。

澳门葡京备用网址 60澳门葡京备用网址 61

>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple('abc')
('a', 'b', 'c')
>>> tuple((1, 2, 3))
(1, 2, 3)
>>> 

View Code

  三.2 基本元组操作(方法)

贰个主意:二个是count(计数),3个是index(索引),当然,它同样能够切条

澳门葡京备用网址 62澳门葡京备用网址 63

names = ('alex', 'jack', 'DJ', 'alex', 'Alex')
print(names.count('alex'))
print(names[names.index('DJ')])
print(names.index('DJ'))

执行:
2
DJ
2

View Code

它们用作映射中的键(以及集聚的成员),而列表不行。
稍加内置函数和艺术再次回到元组,这意味必须跟它们打交道。只要不尝试修改元组,与
元组“打交道”常常意味着像管理列表同样处理它们(必要运用元组未有的index和count等办法时区别)。
相似来说,使用列表足以满意对队列的须要。

  1. 购物车小程序

澳门葡京备用网址 64澳门葡京备用网址 65

product_list = [
    ('IPhone', 6000),
    ('Mac Pro', 12000),
    ('Starbucks Latte', 50),
    ('Bicycle', 800),
    ("Watches", 12000)
]

shopping_list = []
salary = input("Input your salary:")
if salary.isdigit():
        # 判断用户输入的工资是否为数字类型
    salary = int(salary)

    while True:
        for index, item in enumerate(product_list):
            print(index,item)
            # 取出列表元素对应下标,并打印下标和数据
        user_choice = input("Please choose goods:")
        if user_choice.isdigit():
            user_choice = int(user_choice)
            # 判断输入的元素下标是否是数字类型(判断用户的输入是否为数字类型)

            if not user_choice >= len(product_list) and user_choice >= 0:
                p_item = product_list[user_choice]
                # 通过下标把商品取出来
                if p_item[1] <= salary:    # 买得起
                    shopping_list.append(p_item)
                    salary -= p_item[1]
                    print('Added \033[32m %s \033[m into shopping cart,'
                          'Your curent balance is \033[31m %s \033[m' % (p_item, salary))
                else:
                    print("\033[41m 你的余额只剩[%s]啦!\033[m" % salary)
            else:
                print("\033[42m product code [%s] is not exits!\033[m" % user_choice)

        elif user_choice == 'q':
            print("------shopping list------")
            for p in shopping_list:
                print(p)
            print("\033[45m Your current balance:\033[0m",  salary)
            print("------shopping list------")
            exit()
        else:
            print("invalid option!")

View Code

 

 

 

 

 

    

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website