初涉大蟒蛇-python基础篇

Posted 2020-07-22

一些简单概念：

字面常量，也就是我们所说的常量，在计算机中也就是一块内存。

变量：指向内存的一对符号。

文件系统：决定了文件的存放方式。

按位与:   &

按位或：  |

异或：    ^

 

列表：

列表：列表的复制为引用赋值，为浅拷贝，重新复制的时候id值是相同的，两者会同时修改，如果需要独立复制，则需要用切片方法来复制，为深度拷贝。列表相当于其他语言中的数组。

1、列表的基本概念：

>>> f =    [1, 2, 3, 9, 5]                ###定义一个列表

>>> len(f)           ###取列表的长度

5

>>> max(f)           ###取列表的最大值

9

>>> min(f)           ###取最小值

1

>>> 2 in f           ###判断一个字符是否在列表中

True 

>>> del f[0]        ###删除列表中的一个元素，按照列表的下标来删除

>>> f

[2, 3, 9, 5]

2、列表的基本操作

>>> l=[1,2,3,4]

>>> l

[1, 2, 3, 4]

>>> l.append(‘a‘)               ###在列表后面追加一个元素

>>> l

[1, 2, 3, 4, ‘a‘]

>>> l.append([1,2,3])   ###在列表后面追加一个列表

>>> l

[1, 2, 3, 4, ‘a‘, [1, 2, 3]]

>>> l.extend([‘a‘,‘b‘,1,2,3])     ###将这个列表扩展到原来的列表中，并且打散

>>> l

[1, 2, 3, 4, ‘a‘, [1, 2, 3], ‘a‘, ‘b‘, 1, 2, 3]

>>> f=[‘hello‘,‘world‘]

>>> f.extend(l)                 ###将l列表扩展到f列表中

>>> f

[‘hello‘, ‘world‘, 1, 2, 3, 4, ‘a‘, [1, 2, 3], ‘a‘, ‘b‘, 1, 2, 3]

>>> l=[1,2,3,4]

>>> l.insert(1,100)                    ###将100插入到下标为1的前面

>>> l

[1, 100, 2, 3, 4]

>>> l.insert(len(l),1000)         ###将1000插入末尾

>>> l

[1, 100, 2, 3, 4, 1000]

>>> l.insert(1,[1,2,3,4])   ###在列表的下标为1的前面插入一个新的列表

>>> l

[1, [1, 2, 3, 4], 100, 2, 3, 4, 1000]

>>> l.remove(1000)                     ###从左向右删除这个值，一次只能删除一个

>>> l

[1, [1, 2, 3, 4], 100, 2, 3, 4]

>>> l.pop()                                ###从列表中最后的一个值先返回再删除，pop中加参数，代表删除下标对应的数值

4

>>> l

[1, [1, 2, 3, 4], 100, 2, 3]

>>> l

[1, [1, 2, 3, 4], 100, 2, 3]

>>> l.count(1)                          ###在列表中计算1出现的次数

1

[1, [1, 2, 3, 4], 100, 2, 3]      

>>> l.index(1)        ###在列表中查找1所在的下标

0

>>> l.index(3)

4

>>> dir(l)                        ###查看l这个列表的变量

[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__delslice__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__getslice__‘, ‘__gt__‘, ‘__hash__‘, ‘__iadd__‘, ‘__imul__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__reversed__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__setslice__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘append‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘]

 

>>> l.reverse()                ###反向输出列表

>>> l

[‘b‘, ‘a‘, 5, 4, 3, 2, 1, 3, [1, 2, 3, 4], 5, 3, 4, 3, 2, 1]

>>> l.sort()                    ###对列表进行排序

>>> l

[1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, [1, 2, 3, 4], ‘a‘, ‘b‘]

###########注意###########

>>> p

[1, 2, 6, 7, 8, 9, 9, 32, 43, 43, 90]

>>> d=p

>>> d

[1, 2, 6, 7, 8, 9, 9, 32, 43, 43, 90]

>>> d=p.sort()

>>> d

>>> type(d)                    ###此时的d为空，因为p.sort()函数无返回值，所以返回为空，所以d列表中为空

<type ‘NoneType‘>

#########################

>>> l.insert(l.index(3),10)      ###在一个值的前面插入一个元素

>>> l

[1, 2, 10, 3, 4, 5]

>>> l.insert(l.index(3)+1,10)   ###在一个值的后面插入一个元素

>>> l

[1, 2, 10, 3, 10, 4, 5]

 

 

切片：将列表中特定区间中的值输出    例如：  list[1:10:1]    ###起始点：结束点：步长

Python中直接拷贝，两个标签指向的内存在同一个位置，使用切片复制时，属于两个不同的内存

>>> k = l                         ###直接拷贝

>>> l

[1, 2, 10, 3, 10, 4, 5]

>>> k

[1, 2, 10, 3, 10, 4, 5]

>>> id(k)                         ###内存id号和原来的列表id号一致

42219640

>>> k = l[::]                     ###不加起点、终点、步长，代表从列表的第一位输出到列表的最后一位

>>> k

[1, 2, 10, 3, 10, 4, 5]

>>> l

[1, 2, 10, 3, 10, 4, 5]

>>> id(k)                          ###使用切片后，id号会变化

42222872

>>> id(l)

42219640

>>> l

[1, 2, 10, 3, 10, 4, 5]

>>> w = tuple(l)                    ###将一个列表直接转换成元组

>>> w

(1, 2, 10, 3, 10, 4, 5)

 

列表解析：将列表中的数据进行循环运算，性能远远高于for循环

>>> li = [1,2,3]

>>> li2 = [i+1 for i in li]         ###将li列表中的每个元素+1，注意，表达式只能有一个，可以写成无

>>> li2

[2, 3, 4]

>>> for i in li:                       ###上面的列表解析相当于这个for循环，但是效率比for循环的效率高

...  li3.append(i+1)

...

>>> li3

[2, 3, 4]

 

列表解析和元组解析的区别：

>>> li = [1,2,3,4]

>>> li2 = [i+1 for i in li]           ###列表解析，直接通过for循环生成目标列表

>>> li2  

[2, 3, 4, 5]

>>> li2 = (i+1 for i in li)            ###元组解析，生成一个迭代器，每次需要的结果需要使用li2.next输出

>>> li2

<generator object <genexpr> at 0x27b8f00>

>>> type(li2)

<type ‘generator‘>

>>> li2.next()                          ###主动的输出元组中的值，

2

>>> li2.next()

3

>>> li2.next()

4

>>> li2.next()

5

>>> li2.next()

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

StopIteration                           ###此处stop

 

带条件的列表解析：就是在列表解析中加入另外的条件

>>> li3 = [i+1 for i in li if i %2 == 0]       ###将li列表中的偶数元素+1

>>> li3

[3]

>>> id(li3)                                           ###每个列表的id都不同

42219856

>>> id(li)

42219640

   

>>> li4 = [i for i in li if i % 2 == 0 if i > 5]      ###if条件可以写多个，用多个条件对列表进行限制

>>> li4

[6, 8]

 

 

两个列表的笛卡尔积：

>>> li4 = [(i,x) for i in li for x in li1]             ###由于表达式只能有一个，所以用一个元组存放

>>> li4

[(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]

 

 

迭代器的性能远高于列表解析

 

元组：

元组：元组中的值不可更改，但是，在元组中加入列表的时候，此时列表中的值可修改

如果通过完全切片来复制，则两个元组的id号一致

 

集合：

集合：集合中的数据是无序排列的，并且是唯一的，并且会自动将hash值一致的数据进行合并，只有支持hash的数据才可放入集合中，集合不支持切片，声明一个空的集合：s = set()

 

>>> s = {}                       ###默认定义为一个空字典

>>> type(s)

<type ‘dict‘>

>>> s = set()                    ###定义一个空集合

>>> type(s)

<type ‘set‘>

 

>>> s = {1,2,3,1,1,1,‘1‘}        ###定义一个集合

>>> s

set([‘1‘, 1, 2, 3])            ###定义集合时，重复的符号只取其中一个

>>> s = {1,2,3,1,1,1,‘1‘,[1,2,3]}         ###列表不可被hash，所以不能加入集合

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: unhashable type: ‘list‘

>>> s = list(set([1,2,1,2,1,2,1,2]))     ###可以使用集合对列表进行去重

>>> s

[1, 2]

>>> s

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

>>> s.add(100)                               ###在集合中加入一个值，无序排列

>>> s

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

>>> s.update([200,300])               ###将一个列表更新到集合中，注意，不是加入

>>> s

set([1, 2, 3, 4, 200, 300, 100])

>>> s.remove(100)                         ###删除集合中的一个值

>>> s

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

>>> s.pop()                                    ###随即删除集合中的一个值

1

>>> s

set([2, 3, 4, 200, 300])

>>> s.discard(‘a‘)                      ###先在集合中查找这个值，如果没有，不做删除，否则删除

>>> s

set([2, 3, 4, 200, 300])

 

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

>>> type(s1)

<type ‘set‘>

 

集合中的运算：

>>> s1.difference(s)                   ###取s1对s的差集

set([1])

>>> s.difference(s1)                  ###取s对s1的差集

set([200, 300, 4])

>>> s.difference_update(s1)          ###求出差集后修改原值

>>> s

set([1, 5])

>>> s - s1                                  ###做减运算，相当于差集

set([200, 300, 4])

>>> s1 - s

set([1])

>>> s

set([2, 3, 4, 200, 300])

>>> s1

set([1, 2, 3]) 

>>> s.intersection(s1)                ###交集

set([2, 3])

>>> s1.intersection(s)

set([2, 3])

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

>>> s1

set([2, 3, 4])

>>> s.issubset(s1)                       ###子集，如果s1是s的子集，则返回True

False

>>> s1.issubset(s)          

True

>>> s1.isdisjoint(s)                   ###如果两个集合没有共同的元素，则返回True，返回False，相当于intersection的负集

>>> s2.clear()                              ###清空一个集合

>>> s2.issuperset(s1)                  ###相当于issubset的负集

True

>>> s1

set([2, 3, 4])

>>> s2

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

>>> s

set([1, 2, 4])

 

字典：

字典：{key:value}，不能有重复的key，也就是说，key必须可hash，元组可作为key,列表不可以做为key，集合也不可用作key，迭代器的循环效率高于普通循环，字典不支持切片操作，但是支持copy

 

>>> d.keys()                          ###以列表的形式返回key

[‘age‘, ‘name‘, ‘sex‘]

>>> d.values()                      ###以列表的形式返回values

[23, ‘tom‘, ‘male‘]

 

 

>>> it = d.iterkeys()          ###将字典中的key值定义为迭代器

>>> type(it)

<type ‘dictionary-keyiterator‘>

>>> it.next()                        ###主动请求迭代器中的数值

‘age‘

>>> it.next()

‘name‘

>>> it.next()

‘sex‘

>>> it.next()

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

StopIteration

>>> d.items()                       ###将字典中的key:values用元组的形式成对输出

[(‘age‘, 23), (‘name‘, ‘tom‘), (‘sex‘, ‘male‘)]

>>> d.items()

[(‘age‘, 23), (‘name‘, ‘tom‘), (‘sex‘, ‘male‘)]

>>> for i in d.values():            ###输出values

...     print i

...

23

tom

male

>>> for i in d.keys():              ###输出keys

...     print i,d[i]

...

age 23

name tom

sex male

>>> d.get(‘name‘)                    ###获取字典中key所对应的value

‘tom‘ 

>>> d.get(‘eat‘,1111)             ###获取字典中的key值时如果没有这个key值，则返回一个随机值

1111

>>> d[‘name‘]

‘tom‘

>>> d.has_key(‘name‘)             ###可以用来判断key值是否存在

True

>>> d[‘phone‘] = 1111111        ###在字典中添加一个值，如果这个值已经存在，则进行修改

>>> d

{‘phone‘: 1111111, ‘age‘: 23, ‘name‘: ‘tom‘, ‘sex‘: ‘male‘}

 

 

#################函数##################

函数定义：def  func_name():

print  ‘hello’

  func_name()                          ###调用函数

变量：局部变量： 定义在函数内的变量，只能被函数本身调用，该变量为局部变量，当函数需要使用全局变量时，需要使用global 来调用全局变量，函数中存在一种延迟绑定

                  全局变量：定义在函数外部的变量，可以在全局中被调用

当函数名相同时，局部变量的优先级高于全局变量

  1 #!/usr/bin/env python                           ###在linux系统中，该行为指定python的运行目录

  2 #coding=utf-8                                     ###改行为指定使用字符集

  3

  4 def func_name(arg,arg1,arg2,arg3):  #形式参数,作为局部变量

  5      print  arg,arg1,arg2,arg3

  6

  7 func_name(100,99,98,97)       #实际参数,位置传参

  8 func_name(arg3 =100,arg2 = 99,arg1 = 98,arg = 97)   #关键字传参

  9

 10 def func_name1(arg1,arg2,arg3,arg=100):  #带默认值的形式参数一定要定义在所有

    不带默认值参数的后面

 11      print  arg,arg1,arg2,arg3

 12 func_name1(2,3,4)

 

 

可变参数：（数量不一定），当参数传进来后，默认为一个元组，可以解决函数参数不够用的情况

  1 #!/usr/bin/env python

  2 #coding=utf8

  3 def func_name(*arg):     #可变参数传参

  4         #arg is a tuple

  5         print arg        #参数的打包

  6

  7 li = [3,4,5,6,7]

  8 func_name(*li)     #相当于func_name(3,4,5,6,7)

  9

 10 li2 = [‘a‘]

 11

 12 func_name(*li2)    #参数的解包

 13

 14 func_name(1,2)

 15 #([3,4,5,6,7])

例题：

  1 #!/usr/bin/env python

  2 #coding=utf8

  3

  4 def func_name(*arg):

  5     host = arg[0]

  6     port = arg[1]

  7     username = arg[2]

  8     passwd = arg[3]

  9     db = None

 10     if len(arg) == 5:

 11