Fay

基础

高级语言:

                 编译型语言执行速度快,不依赖语言环境运行,跨平台差,如C,C++

                 解释型语言跨平台好,一份代码,到处使用,缺点是执行速度慢,依赖解释器运行,如python,PHP

 

变量的作用:标记数据,存储数据

变量定义规则:变量名只能是字母,数字或下划线的任意组合。第一个字不能是数字。关键字不能声明为变量。

Python单行注释用  #   单行注释用三对单引号 '''    '''    。

数据类型:整形int(),浮点型,字符串str(),布尔类型   Ture,False  一般用于逻辑判断

获取一个字符串的地址用  id

字符串:str                                                                                                                                     

一个有序的集合,用于存储和表示基本的文本信息,一对单双或三引号中间包含的内容为字符串。

特性:有序,不可变(一旦声明不可变)

str.swapcase()  #将字符串由小写全部转换为大写,由大写全部变成小写。

str.captalize()  \  title()   # 首字母大写。

str.upper()  #全部变成大写

str.casefold() \lower()  #全部变成小写

str. center(n)  #  以什么为中心。加多少个,什么字符进去。

例: 
str1 = "[runo测试ob]" print( str1.center(40, '*')) #以str1这个字符串为中,左右俩边添加字符进去,也可不添加字符进去 结果:***************[runo测试ob]***************

  

str.count(n)  # 计算出现的次数。 

startswith()  #检测字符串是否以指定的前缀开始。

endswith(n) #检测字符串是否以指定的结尾结束。

expandtabs(n)  # 扩展tabs键,将tabs的长度变长,默认的tabs键长度为8.

find()  #查找一个值,并且返回其索引位置,找不到就返回一个负数。

format() 传递,格式化的另外一种方法。

index(n)  #返回字符串的索引值,可以 start,end.

isdiggit()  #判断是不是一个整数。

join() #将列表变成字符串之后,以什么来区分每一个列表里的元素。

strip() #脱掉

split(n)#将字符串分成一个列表。

replace()   #  替换

 

列表:                                                                                                                                                   

列表 是一个数据的集合,集合内可以放任何数据类型,可对集合进行方便的增删改查操作

 

创建 [ ]

查询 .index(), 切片 [_ : _]

 

 n2=["shanshan","tongjie","xiaoyu",1,3,4,4,5,6,7,7,8,8,8,8,0,0,2,3,4,4]

 

 n2[3] #取前面几个值,注意这里是中括号[].

 

1

 

>>> n2[-4]#通过索引从列表右边开始取值

 

2

 

>>> n2[-2]

 

4

 

#取后面几个数的值,可以这样取,那么中间的数就不好去具体数。针对一个列表有很多元素,中间的就不可能进行直接数。那么就引入了 .index()可以直接根据具体的值来进行索引。找到在列表中的哪一个位置然后再进行调用.

 

n2.index(8) #先根据值用index()找位置

 

11

 

n2[11] #再根据得到的具体位置进行调用,那么中间的数就可以不用去数。

 

8

 

#列表里有一个值为8,而用index进行找,就会自动将列表中的第一次出现8的这个值得索引位置给表示出来。就得出8这个值得位置在第11这个地方。

 

>>> n2.index(4)#4这个值得位置在第5.

 

5

 

>>> n2[5] #调用5这个位置的值为4

 

4

 

>>> n2[n2.index(4)] # 可以简化成这样的格式,就可以直接调用4这个值。

 

4 这里需要注意的是如果直接用n2[4]得出的值会是3。

 

举例说明: n2[n2.index("shanshan")]

 

          'shanshan'

 

          >>> n2[n2.index("xiaoyu")]

 

          'xiaoyu'

 

>>n2.count(8) # 统计指定元素的个数.count()

 

4

 

n2.count("shanshan")#如果是字符串的话必须加引号

 

1

 

切片 [ : ]

 

n2 = ["shanshan","tongjie","xiaoyu",1,3,4,4,5,6,7,7,8,8,8,8,0,0,2,3,4,4]

 

 

n2[0:3] #索引0至3的元素,不包括3,顾头不顾尾。

 

['shanshan', 'tongjie', 'xiaoyu']

 

n2[ :-1] #索引0至最后一个的值,不包括最后一个值。

 

['shanshan', 'tongjie', 'xiaoyu', 1, 3, 4, 4, 5, 6, 7, 7, 8, 8, 8, 8, 0, 0, 2, 3, 4]

 

n2[:] #索引0到最后一个的值相当与复制一个相同的列表

 

['shanshan', 'tongjie', 'xiaoyu', 1, 3, 4, 4, 5, 6, 7, 7, 8, 8, 8, 8, 0, 0, 2, 3, 4, 4]

 

 

n2[3:6]#索引3至6的元素,或者 n2[1:7]

 

[1, 3, 4] ['tongjie', 'xiaoyu', 1, 3, 4, 4]

 

 例:

 

n3 = ['shanshan','alibab','xiaouu','xiaojiay','tgy','xyz',7]

 

n3[ :6:1] #取从0至6的值,但不包括6.间隔为1取一个值。

 

['shanshan', 'alibab', 'xiaouu', 'xiaojiay', 'tgy', 'xyz']

 

n3[ 1:6:1] #取从1至6的值,但不包括6.步长为1,间隔为1取一个值。

 

['alibab', 'xiaouu', 'xiaojiay', 'tgy', 'xyz']

 

 

n3[ 1:6:2]#取从1至6的值,但不包括6.步长为2,间隔为2取一个值。,

 

['alibab', 'xiaojiay', 'xyz']

 

 

n3[ 1:6:3] #取从1至6的值,但不包括6.步长为3,间隔为3取一个值

 

['alibab', 'tgy']

 

n3[: : 1]#取从头至尾的值.步长为1,间隔为1取一个值即不跳相当于复制一个相同列表

 

['shanshan', 'alibab', 'xiaouu', 'xiaojiay', 'tgy', 'xyz', 7]

 

 n3[: : 2] #取从头至尾的值.步长为2,间隔为2取一个值。

 

['shanshan', 'xiaouu', 'tgy', 7]

 

n3[: : 3] #取从头至尾的值.步长为3,间隔为3取一个值。

 

['shanshan', 'xiaojiay', 7]

 

添加/追加 .apped(n) 列表尾部添加

 

 L = ['shanshan', 'xiaoyu', 'zhangsan', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17]

 

>>> L.append("haha")

 

>>> L

 

['shanshan', 'xiaoyu', 'zhangsan', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17, 'haha']

 

插入 任意位置 .insert(position,"value")选择插入的位置,值

 

 L.insert(3,"夏雨荷")

 

>>> L

 

['shanshan', 'xiaoyu', 'zhangsan', '夏雨荷', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17, 'haha']

 

修改 L[position] = "value" 直接把被改的元素位置赋值给要替换的新元素

 

L = ['shanshan', 'xiaoyu', 'zhangsan', '夏雨荷', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17, 'haha']

 

>>> L[3] = "dave"

 

>>> L

 

['shanshan', 'xiaoyu', 'zhangsan', 'dave', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17, 'haha']

 

删除 最后一个元素 .pop()

 

L.pop()

 

'haha'

 

>>> L

 

['shanshan', 'xiaoyu', 'zhangsan', 'dave', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17]

 

删除其中一个元素 .remove(n)

 

L = ['shanshan', 'xiaoyu', 'zhangsan', 'dave', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17]

 

>>> L.remove("dave")

>>> L

['shanshan', 'xiaoyu', 'zhangsan', 'lisi', 'wangmazi', 3, 7, 4, 5, 9, 11, 17]

 

删除 全部或者单独元素 del / del 变量名[n]

 

del L[3]

>>> L

['shanshan', 'xiaoyu', 'zhangsan', 'wangmazi', 3, 7, 4, 5, 9, 11, 17]

>>>

del L

Traceback (most recent call last):

  File "<pyshell#8>", line 1, in <module>

    L

NameError: name 'L' is not defined #这就表示全部删除了

 

L = ['shanshan', 'xiaoyu', 'zhangsan', 'wangmazi', 3, 7, 4, 5, 9, 11, 17]

>>> del L[2:4]

>>> L

['shanshan', 'xiaoyu', 3, 7, 4, 5, 9, 11, 17] 利用切片删除

 

循环 for 变量名 in 变量名 :

把列表里的每一个值取出来赋给 i ,i是一个临时变量。交给print执行下面的语句,依次循环列表里的值。

L2 = ["a","b","c","L","e",1,2]

for you in L2: #这后面一定要有冒号

print(you)

a

b

c

L

e

1

2

 

举例

range(10)

range(0, 10)

>>> for i in range(10):

    print(i)

 

 

0

1

2

3

4

5

6

7

8

9

>>> for k in range(10):

    print(k)

 

 

0

1

2

3

4

5

6

7

8

9

 

排序 .sort () 按照askll码值得大小进行排序

n = ["!","*","#","a","b","c","e","y","z"]

n.sort()

>>> n

['!', '#', '*', 'a', 'b', 'c', 'e', 'y', 'z']

            .reverse() 原地翻转 倒过来

n.reverse()

>>> n

['z', 'y', 'e', 'c', 'b', 'a', '*', '#', '!']

>>>

 

拼接 直接 + / n1.extend(n2)

 

n1 = ["!","*","#","a","b","c","e","y","z"]

n2 = [1,2,4]

n1+n2

['!', '*', '#', 'a', 'b', 'c', 'e', 'y', 'z', 1, 2, 4]

 

n1.extend(n2)

 

n1.extend(n2)

>>> n1

['!', '*', '#', 'a', 'b', 'c', 'e', 'y', 'z', 1, 2, 4]

 

清除 n.clear() 清除了整个列表与del的作用一样但语法不一样

 

n1 = ["!","*","#","a","b","c","e","y","z"]

>>> n1.clear()

>>> n1

[]

 

拷贝 n.copy() 这里注意区分 在变量里

 

n = [3,4,5] a = 7

 n4 = n b = a 当b = a时,b的值是指向a的值,并不会因为a的值变化而变化

 n a

[3, 4, 5] 7

 n4 b

[3, 4, 5] 7

 n[2] = "jack" a = 19

  n a

   [3, 4, 'Jack'] 19

    n4 b

[3, 4, 'Jack'] 7

 而这里的copy,是复制的意思

所以会根据n的值变化而变化

 

例题讲解引入 枚举 enumerate

 

 

循环names列表,打印每个元素的索引值的元素

 

names = ["xiaoli","xiaohua","xiaohuang","xiaohei","mali"]

for j in enumerate(names):#注意格式后面加冒号

print(j)

 

(0, 'xiaoli')

(1, 'xiaohua')

(2, 'xiaohuang')

(3, 'xiaohei')

(4, 'mali') #看输出的结果就把每一个元素和索引值都打印出来了

 

前面输出的结果里有括号,如何去除括号呢,

names = ["xiaoli","xiaohua","xiaohuang","xiaohei","mali"]

for index, j in enumerate(names):

print(index,j)

 

0 xiaoli

1 xiaohua

2 xiaohuang

3 xiaohei

4 mali #这样就把括号去除了,是因为前面的 j,只是代表一个变量只能用括号括起来,

                     而俩个值的话,用逗号即可,也把括号去除掉了

 

names = ["xiaoli","xiaohua","xiaohuang","xiaohei","mali"]

for a ,j in enumerate(names):

print(a,j)

 

0 xiaoli

1 xiaohua

2 xiaohuang

3 xiaohei

4 mali #我试了下j前面的变量名其实可以用其他的来代替,不一定非得用index,用index的主要目的是让人明白元素的位置在具体的地方,让人一目了然,因为之前就学了index的作用就是找一个元素的索引值

 

# 循环names列表,打印每个元素的索引值的元素,当索引值为偶数时,把对应的元素改为-1

names = ["xiaoli","xiaohua","xiaohuang","xiaohei","mali"]

for index,j in enumerate(names): #枚举

if index %2 == 0: #偶数

names[index] = -1#接上一句如果Index的索引值是偶数,就将偶数的值全部重新赋值为-1

print(index,j)

print(names)

 

0 xiaoli

2 xiaohuang

4 mali

[-1, 'xiaohua', -1, 'xiaohei', -1]

 

index()返回字符串的索引值,可以start,end

 

 

 

 

 

字典:

数据类型-字典

字典一种key -value的数据类型

特性:

key -value结构

key必须可hash且必须为不可变的数据类型,必须唯一(即命名的key名不能重复)

可存放任意多个值,可修改,可以不唯一(value可是任意多个值,且可修改,值可以任意定)

无序

查找速度快

  语法:

info = {"n1":["a1","b1","c1","d1","e1","f1","g1"],"n2“:["a2","b2","c2","d2","e2","f2","g2"]}

 

增加

info["n3"]=["a3","b3","c3","d3","e3","f3","g3"] #后面可以增加很多个或者一个值

>>> info

{'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n2': ['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2'], 'n3': ['a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3']}

>>>

 

info["n2"][1]+="今天大年初一"#增加某一个值的单项用+=

>>> info["n2"][1]+="今天大年初一"

{'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n2': ['a2', 'b2今天大年初一', 'c2', 'd2', 'e2', 'f2', 'g2'], 'n3': ['a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3']}

>>>

 

修改

info["n3"]= "今天要学习"#直接赋值key的n3,value的值就变成“今天要学习”,但却把原先赋值的覆盖了

>>> info

{'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n2': ['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2'], 'n3': '今天要学习'}

>>>

 

查找 in

 

 

"n3" in info #判断在不在里边

True

 

获取 get 如果获取没有的值,print一下就会返回一个none而不是报错。

info.get("n2")

['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2']

>>>

info.get("n7")

>>> print(info.get("n7"))

None#这里没有n7,如果打印出来就会直接返回none

>>>

 

当然也可以这样,只是要报错,一般不采用

info["n7"]

Traceback (most recent call last):

  File "<pyshell#188>", line 1, in <module>

    info["n7"]

KeyError: 'n7'

 

用info. 加上Tab键就可以自动补全,看所有关于字典的关键字,包括删除之类

 

删除 pop(n)删除一个值同时返回对应的值

 

info.pop("n3")

['a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', '今天要学习', 'hahah ']

 

popitem()随机删

del info["n2"]#删除其中一个

>>> info

{'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n3': ['a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3', '今天要学习', 'hahah ']}

 

>>> del info#删除全部,注意语法

>>> info

Traceback (most recent call last):

  File "<pyshell#250>", line 1, in <module>

    info

NameError: name 'info' is not defined

>>>

 

info.clear()#清除

info.copy()#复制

info.values()#获取打印字典的所有values

info.keys()#获取打印字典所有的key

info.items()#把字典转成一个列表

info={'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n2': ['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2'], 'n3': ['a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3']}

>>> info.items()

dict_items([('n1', ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1']), ('n2', ['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2']), ('n3', ['a3', 'b3', 'c3', 'd3', 'e3', 'f3', 'g3'])])

>>>

 

info.update(n)合并字典,根据key不能命名一样的原则,合并俩个字典时,相同的key值会被覆盖,

info = {"n1":["a1","b1","c1","d1","e1","f1","g1"],"n2:["a2","b2","c2","d2","e2","f2","g2"]}

names = {"xiaoli":[22,"gilr"],"n2":["a2","b2","c2","d2","e2","f2"]}

info.update(names)

>>> info

{'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n2': ['a2', 'b2', 'c2', 'd2', 'e2', 'f2'], 'xiaoli': [22, 'gilr']}

>>>

 

>>> info.setdefault(n,n)疑问这样起什么作用

info.setdefault("test","new2")

'new2'

{'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n2': ['a2', 'b2', 'c2', 'd2', 'e2', 'f2'], 'xiaoli': [22, 'gilr'], 'test': 'new2'}

>>> info.setdefault("test","new2")

'new2'

>>> info

{'n1': ['a1', 'b1', 'c1', 'd1', 'e1', 'f1', 'g1'], 'n2': ['a2', 'b2', 'c2', 'd2', 'e2', 'f2'], 'xiaoli': [22, 'gilr'], 'test': 'new2'}

>>>

 

info.fromkeys(n,n)#生成一个新的字典

info.fromkeys()#生成一个新的字典key分别为A,B,C,而Value值同为Alex的新字典

info.fromkeys(["A","B","C"],"alex")

{'A': 'alex', 'B': 'alex', 'C': 'alex'}疑问这样起什么作用

 

多级字典嵌套

 

字典循环 for in :

 

info = {"n1":["a1","b1","c1","d1","e1","f1","g1"],"n2":["a2","b2","c2","d2","e2","f2","g2"]}

>>> for k in info:

    print(k)#只打印key

n1

n2

 

for i in info:#这里必须重新for一次

    print(k,info[k])#打印key与value的值

 

 

n1 ['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2']

n2 ['a2', 'b2', 'c2', 'd2', 'e2', 'f2', 'g2']

 

集合

集合是一个无序,不重复的数据组合。

作用:

去重,把一个列表变成集合,就自动去重

关系测试,测试俩组数据之间的交集,差集,并集的关系

 

特征:

1.确定性(元素必须可hash)

2.互异性(去重)

3.无序性(集合中的元素没有先后之分),如集合{3,4,5}和{3,5,4}算作同一个集合

 

语法:s = { }#注意是花括号

 

自动去重功能

s = {1,2,3,5,1,2,4,5,3,7,9,7}

>>> s

{1, 2, 3, 4, 5, 7, 9}

 

set(n) 或者 n=set(n) #把一个列表,元组转成一个集合,字典不能被转化哦

 

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

>>> set(L)#直接定义大括号

{1, 2, 3, 4, 5}

 

s= (1,2,3,4,5,6,2,4,)

>>> s = set(s)#把s的值传递进去给set,然后直接赋值转化

>>> s

{1, 2, 3, 4, 5, 6}

>>>

 

.add(n)增加一个值,但不能增加相同的值在集合里去,因为集合有自动去重功能

.pop()删除,随机删除一个值,集合是无序的

.remove(n),删除,指定删除某一个值,如果删除一个没有的值会报错

.discard(n)丢弃,指定删除某一个值,但与remove有区别,如果删除一个没有的值不会报错。

.update()增加,多个值

 

集合关系测试

intersection 或者 & 交集 指俩个集合都有的共同点和交叉点

 

difference 或者 - 差集 指俩个集合无共同点的俩边

 

union 或者 |(管道符)并集 把俩个集合变成一个大集合,并且把重复的去掉

 

isdisjoint(n) 不相交 判断俩个集合是不是不相交

s = {1, 2, 3, 4, 5, 6}

>>> s1 = {1, 2, 3, 4, }

>>> s.isdisjoint(s1)#判断s 与s1不相交

False#答案为假。是因为s与s1相交

 

s = {1, 2, 3, 4, 5, 6}

>>> s1={7,8,9,10}

s.isdisjoint(s1)#判断s 与s1不相交

True#答案为真,是因为s与s1确实不相交

>>>

 

.symmetric_difference(n) 对称差集 指将俩个集合不相交的俩边放在一起

s = {1, 2, 3, 4, 5, 6}

>>> s1 = {1,2,7,8,9,13}

>>> s.symmetric_difference(s1)

{3, 4, 5, 6, 7, 8, 9, 13}#s与s1中不相交的值,放在一起组成一个新的集合

 

包含关系

 

.issuperset(n) 判断俩个集合是不是有包含关系,等同于a>=b

.issubset(n) 判断俩个集合是不是有被包含关系,等同于a<=b

 

s = {3,4,5,6,7}

 s1 ={3, 4, 5, 6, 7, 8, 9, 13}

s1.issuperset(s)或者 s1 >= s

True #s1的值全部包含s的值,可理解为s1>=s

反之

s.issuperset(s1)

False #则报错,这就是包含关系

 

s.issubset(s1)或者s <= s1

True #s 的值被s1全部包含,可理解为s<=s1

>>> s1.issubset(s)

False

其实包含关系,可以理解为,假如A为大,B为小,A>B,A就把B包含进去了,用issuperset,

而B<A,B就必须被包含,顺从于A,用issubset.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

                       

posted on 2018-03-09 11:34  sunny7  阅读(280)  评论(0编辑  收藏  举报

导航