Python基础-基本语法，内置容器

最新推荐文章于 2021-07-04 19:40:21 发布

同乐乐

最新推荐文章于 2021-07-04 19:40:21 发布

阅读量313

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/tongyijia/article/details/52602656

版权

python 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Python的一些小知识

Python 第一个版本于1989年圣诞节发布
Python2.0 2000年发布
Python3 2008年发布不兼容python2，目前两者共存
通常所说的python由C开发，除此之外还有jython（java开发），ironpython(运行在.net平台上，兼容.net库)
pypy（由python写的python）
此篇博客主要运用python2.7

第一个简单的python程序

直接使用交互式Python

root@tonglele /mnt # python
Python 2.7.5 (default, Feb 11 2014, 07:46:25)
[GCC 4.8.2 20140120 (   Hat 4.8.2-13)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> print "hello world"
hello world

使用vim编辑一个python程序，并用python指令运行

vim test.py

1 2	#!/usr/bin/env python print "hello world"

此时：第一行 #!/usr/bin/env python 表示引用环境变量里自定义的python版本，具有可移植性，推荐这种写法
也可以写成 #!/usr/bin/python 这种写法直接引用系统默认的python版本，这样此程序移植到其他机子上运行的时候可能和你预期使用的版本不同
结果：

1 2	root@tonglele /mnt # python test.py hello world

或者：

root@tonglele /mnt # ll
total 4.0K
-rw-r--r-- 1 root root 42 Jun  4 21:10 test.py
root@tonglele /mnt # chmod +x test.py 
root@tonglele /mnt # ./test.py 
hello world

输出汉字的问题

由于python2的发布在unicode发布之前，所以它默认的是ascii编码，在我们想要显示汉字时应该显示的指定编码

1 root@tonglele /mnt # cat test.py                                                                           :(
#!/usr/bin/env python

print "hello world"
print "你好！世界！"
root@tonglele /mnt # ./test.py  
  File "./test.py", line 4
  SyntaxError: Non-ASCII character '\xe4' in file ./test.py on line 4, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details

        )

root@tonglele /mnt # cat test.py
#!/usr/bin/env python
# coding=utf-8
print "hello world"
print "你好！世界！"
root@tonglele /mnt # ./test.py  
hello world
你好！世界！

基本概念

变量

指向内存中一段区域的符号（类似于C中的指针）
命名规范：由字母，数字，下划线，组成，不以数字开头，关键字不能作为变量名
python中的所有变量都是引用

数据类型

首先介绍一个函数type（），它可以查看变量或常量的数据类型

>>> type(1)
<type 'int'>
>>> a = 1
>>> type(1)
<type 'int'>
>>> type(2)
<type 'int'>
>>> type(2.0)
<type 'float'>
>>> type(True)
<type 'bool'>

python是一种强类型的动态语言,每一个数据都有一个类型,不同类型之间的数据不能做运算,如数字和字符不能相加.所谓的动态语言是指,数据类型可以
在运算时改变
在python中数据类型分为字符串型和数字型（整型，浮点型，长整型）

>>> a = 'tonglele'    #字符串型
>>> b = 10         #整型
>>> c = 2.3        #浮点型
>>> b + c
12.3          #都是数字型则可以相加
>>> a +b   #一个数字型一个字符串型，相加会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: cannot concatenate 'str' and 'int' objects
>>> int(c)    #c为浮点型，精度比整型高，所以在从高精度向低精度转化时会有数据损失
2

运算符和表达式

算术运算符 + / * // %
位操作运算符<< >> & | ^ ~
比较运算符 < <= >= == > !=
逻辑运算符 and or not
赋值运算符 =
其他运算符

>>> 7 / 2      #两个整型相除得到一个整型，精度丢失问题
3
>>> 7 /2.0    #将其中一个换为float类型，得到的为float类型
3.5
>>> 3 ** 2   #幂运算
9
>>> 10 // 3  #除法取整
3
>>> 10 % 3  #取余
1
>>> 2 << 3  #左移位 （效率高）
16
>>> 8 >> 2 #右移位（效率高）
2
>>> 3 & 2  #按位与
2
>>> 3 | 2  #按位或
3
>>> 3 ^ 2  #异或
1

优先级

单目运算符高于双目运算符,not例外; 单目运算符,只有一个数的运算符,如正负号,按位取反,not .python里没有三目运算符
算数运算符高于位运算符
位运算符高于比较运算符
比较运算符高于逻辑运算符
赋值运算符优先级最低
（）提示运算符的优先级

程序结构

if-else语句

1 2	if condition: expression

root@tonglele /mnt # cat if.py 
#!/usr/bin/env python
if 3 < 4:
    print "3 less than 5"
else:
    print "4 less than 3"
root@tonglele /mnt # python if.py 
3 less than 5

elif语句

python中没有switch case语句，但我们可以用很多个elif语句，完成的效果相同

 
#!/usr/bin/env python
a = 1
if a == 1:
    print "a is 1"
elif a == 2:        #可以有多个elif
    print "a is 2"
else:
    print "a is ?"

循环结构

while 语句

vim while.py

#!/usr/bin/env python
a = 0
while a < 5:
    print a
    a += 1

=========结果===
root@tonglele /mnt # python while.py 
0
1
2
3
4

for语句

for item in iterator:
expression

#!/usr/bin/env python
for i in range(1,10):   #in 后跟一个迭代器
    print i

======结果=====
root@tonglele /mnt # python for.py  
1
2
3
4
5
6
7
8
9

python内置容器

列表

列表是我们常用的一种内置的容器，它可以将不同数据类型的值存储再一个列表中。

初始化一个列表

>>> li = []
>>> li2 = list()
>>> type(li)
<type 'list'>
>>> type(li2)
<type 'list'>

列表的下标

列表是有序的，下标从0开始

>>> li = [1,2,3,4]
>>> li[0]
1
>>> li[2]
3
>>> len(li)    #len()函数，得到list的长度
4

一些简单的操作

>>> li
[1, 2, 3, 4]
>>> del li[0]   #删除列表的第0个元素
>>> li
[2, 3, 4]
>>> 4 in li    #判断一个值是否在列表中
True
>>> 5 in li
False

列表（list 对象）的一些方法

1
2

>>> dir(li)   #查看li的方法
['__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']

append

在原列表后追加元素

>>> li
[1, 2, 3, 4, 5, 5]
>>> li.append(100)
>>> li
[1, 2, 3, 4, 5, 5, 100]
>>> li.append([90,89])
>>> li
[1, 2, 3, 4, 5, 5, 100, [90, 89]]

extend

在列表后扩展

>>> li = [1,4,5]
>>> li
[1, 4, 5]
>>> li.extend([9,80,777])
>>> li
[1, 4, 5, 9, 80, 777]

insert

向列表中插入元素

>>> li
[1, 2, 3, 222, 4]
>>> li.insert(1,'hello')    #第一个参数为插入的位置的下标，第二个参数为要插入的元素
>>> li
[1, 'hello', 2, 3, 222, 4]

remove

删除列表中的元素

>>> li
[1, 1, 2, 4]
>>> li.remove(1)   #如果这个元素在列表中出现多次，默认删除下标值小的那个
>>> li
[1, 2, 4]
>>> li.remove(4)
>>> li
[1, 2]

pop

返回一个列表中的元素，可以指定下标，若未指定则默认为最后一个,并将其从列表中删除

>>> li
[2, 3, 5, 6]
>>> a = li.pop()
>>> a
6
>>> li
[2, 3, 5]
>>> 
>>> b = li.pop(1)
>>> b
3

count

返回某个值在列表中出现的次数

>>> li
['a', 'a', 1, 1, 7]
>>> li.count('a')
2
>>> li.count(7)
1

index

返回第一个所查值的下标:

>>> li
['a', 'a', 1, 1, 7]
>>> li.index(1)
2
>>> li.index('a')
0
>>> li.index(7)
4

sort

对列表按升序排列

>>> li = [2,6,3,7,10]
>>> li.sort()
>>> li
[2, 3, 6, 7, 10]

reverse

将列表反转

>>> li
[2, 3, 6, 7, 10]
>>> li.reverse()
>>> li
[10, 7, 6, 3, 2]

list切片

>>> li
[10, 7, 6, 3, 2]
>>> li[2:4]   #从下标为2的元素切到4-1
[6, 3]


>>> li
[10, 7, 6, 3, 2]
>>> li[2:5:1]   #第三个参数代表步长
[6, 3, 2]
>>> li[2:5:2]
[6, 2]

>>> li
[10, 7, 6, 3, 2]
>>> li[::-1]     #将列表反转
[2, 3, 6, 7, 10]

#列表的拷贝为传址
>>> li
[10, 7, 6, 3, 2]
>>> li2 = li
>>> li2
[10, 7, 6, 3, 2]
>>> li2.append(1000)
>>> li2
[10, 7, 6, 3, 2, 1000]
>>> li
[10, 7, 6, 3, 2, 1000]
>>> id(li)
140270212409896
>>> id(li2)
140270212409896

#深拷贝
>>> li
[10, 7, 6, 3, 2, 1000]
>>> li2 = li[:]
>>> li2
[10, 7, 6, 3, 2, 1000]
>>> id(li)
140270212409896
>>> id(li2)
140270403391360

>>> li
[10, 7, 6, 3, 2, 1000]
>>> li[::2]   #得到下标为偶数的元素
[10, 6, 2]
>>> li[1::2]  #得到下标为奇数的元素
[7, 3, 1000]

列表的切片操作是一个复制操作,并不对原始列表进行修改。

列表解析

[expression for item in iterator]
此处只做简要介绍，具体使用我会再开一篇博文

>>> li
[10, 7, 6, 3, 2, 1000]
>>> [x + 1 for x in li]
[11, 8, 7, 4, 3, 1001]

>>> t = (x + 1 for x in li)   #得到一个生成器
>>> t.next()
11
>>> t.next()
8
>>> t.next()
7

元组

元组是有序的，元组的元素是不可改变的，元组的元素也支持下标操作

定义和初始化元祖（tuple）

>>> t = ()
>>> type(t)
<type 'tuple'>
>>> t1 = tuple()
>>> type(t1)
<type 'tuple'>

元组的切片操作

>>> t
(1, 2, 3, 5)
>>> t[0]
1
>>> t[1:3]
(2, 3)
>>> t[3] = 1000   #元组元素不可改变
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: 'tuple' object does not support item assignment

元组中列表元素的修改

>>> t
(1, 2, 4, 'a', [1, 3, 100])
>>> t[4][2] = 200
>>> t
(1, 2, 4, 'a', [1, 3, 200])

元组的count,index

>>> t = (1,1,'a','hello',[1,2])
>>> t.count(1)
2
>>> t.index('a')
2

集合

集合是无序的，集合中的元素不重复，python根据合中的每个元素的hash值来判断是否重复,所以集合中的每个元素必须是可hash的对象。在python中如果一个对象有一个hash 的方法,
表示该对象可hash
集合不支持切片操作

>>> s = set()  #集合的定义方式
>>> type(s)
<type 'set'>
>>> s1 = {}   #不能这样定义集合，这样的定义为字典
>>> type(s1)
<type 'dict'>

>>> s = {1,1,1,3,'a','hello'}
>>> s
set(['a', 1, 3, 'hello'])   #集合中的元素不重复，无序

>>> s = {1,1,1,3,'a','hello',[1,2]}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  TypeError: unhashable type: 'list'    #集合中的元素必须可哈希

集合的一些简单操作

add

向集合中增加元素

>>> s
set(['a', 1, 3, 'hello'])
>>> s.add(23)
>>> s
set(['a', 1, 3, 'hello', 23])

update

迭代器作为参数,将迭代器中的所有元素追加到集合中

>>> s
set(['a', 1, 3, 'hello', 23])
>>> s.update([4,67,'hu'])
>>> s
set(['a', 1, 3, 4, 'hu', 67, 23, 'hello'])

remove

删除集合中的某个元素，若不存在则报错

>>> s
set(['a', 1, 3, 4, 'hu', 67, 23, 'hello'])
>>> s.remove(1)
>>> s
set(['a', 3, 4, 'hu', 67, 23, 'hello'])
>>> s.remove(100)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  KeyError: 100
  "</stdin>"

discard

删除某个元素,若该元素不存在则不做任何操作。

>>> s
set(['a', 3, 4, 'hu', 67, 23, 'hello'])
>>> s.discard(4)
>>> s
set(['a', 3, 'hu', 67, 23, 'hello'])
>>> s.discard(100)
>>> s
set(['a', 3, 'hu', 67, 23, 'hello'])

pop

随机删除某个元素,并返回该元素

>>> s
set(['a', 3, 'hu', 67, 23, 'hello'])
>>> s.pop()
'a'
>>> s
set([3, 'hu', 67, 23, 'hello'])

clear

清空集合

>>> s
set(['hu', 67, 23, 'hello'])
>>> s.clear()
>>> s
set([])

集合的运算

difference

两个集合的差集，不修改原来两个集合

>>> s1 = {1,2,3,4}
>>> s2 = {4,5,6,7}
>>> s1.difference(s2)
set([1, 2, 3])
>>> s2.difference(s1)
set([5, 6, 7])
>>> s1 -s2   #也可直接用减号
set([1, 2, 3])

difference_update

两个集合的差集,但修改原来的集合,不返回值

>>> s1
set([1, 2, 3, 4])
>>> s2
set([4, 5, 6, 7])
>>> s1.difference_update(s2)
>>> s1
set([1, 2, 3])

intersection intersection_update

intersection 两个集合的交集,返回值,不修改原来的集合
intersection_update 两个集合的交集,无返回值,修改原来的集合
具体实现参见difference difference_update

其他

>>> s1
set([1, 2, 3, 4, 5])
>>> s2
set([4, 5, 6, 7])
>>> s1 & s2    #直接求交集
set([4, 5])
>>> s1.union(s2)   #求并集
set([1, 2, 3, 4, 5, 6, 7])
>>> s1  | s2    #求并集
set([1, 2, 3, 4, 5, 6, 7])

>>> s1.isdisjoint(s2)   #查看是否有交集，有则返回False
False
>>> s1.issubset(s2)    #看s1是否为s2的子集，是则返回为True
False

字典

初始化

>>> t = {}
>>> type(t)
<type 'dict'>
>>> t = {'name':'tonglele','age':18}    #存放健值对
>>> t
{'name': 'tonglele', 'age': 18}
>>> t = {'name':'tonglele','name':'tongyijia'}
>>> t
{'name': 'tongyijia'}    #字典中key不允许重复，后者覆盖前者，而且必须是可哈希

字典的一些操作

keys

将字典的所有key作为一个列表返回

>>> t
{'name': 'tonglele', 'age': 18}
>>> t.keys()
['name', 'age']

iterkeys

将字典的所有key作为一个迭代器返回

>>> t
{'name': 'tonglele', 'age': 18}
>>> t.iterkeys()
<dictionary-keyiterator object at 0x7f295c40ec00>
>>> it = t.iterkeys()
>>> it.next()
'name'
>>> it.next()
'age'
>>> it.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  StopIteration

values

返回一个列表,该列表是所有元素的值

>>> t
{'name': 'tonglele', 'age': 18}
>>> t.values()
['tonglele', 18]

items

返回一个列表,列表中的每个元素是一个元组,元组中的两个值分别是key和value

>>> t
{'name': 'tonglele', 'age': 18}
>>> t.values()
['tonglele', 18]
>>> t
{'name': 'tonglele', 'age': 18}
>>> t.items()
[('name', 'tonglele'), ('age', 18)]
>>> for i,j in t.items():
...     print i,j
... 
name tonglele
age 18

get

按照key取值,若存在则返回,否则返回None
可以给get 传递第二个参数,表示若key不存在,则返回这个值。

>>> t
{'name': 'tonglele', 'age': 18}
>>> t.get('name')
'tonglele'
>>> t.get('num')
>>> t.get('num',9)
9

has_key

判断某个key是否存在,返回True/False

>>> t
{'name': 'tonglele', 'age': 18}
>>> t.has_key('name')
True
>>> t.has_key('num')
False

给字典一个键值对

>>> t
{'name': 'tonglele', 'age': 18}
>>> t['num'] = 97
>>> t
{'num': 97, 'name': 'tonglele', 'age': 18}

>>> t
{'num': 97, 'name': 'tonglele', 'age': 18}
>>> t.update({'address':'shannxi','school':'XAUT'})
>>> t
{'school': 'XAUT', 'num': 97, 'name': 'tonglele', 'age': 18, 'address': 'shannxi'}

Python 字典为引用传值

>>> t1 = t
>>> id(t)
9015776
>>> id(t1)
9015776

字典的复制

>>> t
{'school': 'XAUT', 'num': 97, 'name': 'tonglele', 'age': 18, 'address': 'shannxi'}
>>> t1 = t.copy()
>>> t1
{'school': 'XAUT', 'num': 97, 'name': 'tonglele', 'age': 18, 'address': 'shannxi'}
>>> t
{'school': 'XAUT', 'num': 97, 'name': 'tonglele', 'age': 18, 'address': 'shannxi'}
>>> id(t1)
8985424
>>> id(t)
9015776