Python入门的基础知识

转自：https://www.cnblogs.com/chengxuyuanaa/p/12731846.html

python变量和数据类型

数据类型

print语句

注释

python的注释以 # 开头，后面的文字直到行尾都算注释

# 这一行全部都是注释...
print 'hello' # 这也是注释

这里要注意注意：不管你是为了python就业还是兴趣爱好，记住：项目开发经验永远是核心，如果你没有2020最新python入门到高级实战视频教程，可以去小编的python交流.裙 ：七衣衣九七七巴而五（数字的谐音）转换下可以找到了，里面很多新python教程项目，还可以跟老司机交流讨教！

什么是变量

定义字符串

字符串可以用''或者""括起来表示。

如果字符串本身包含'怎么办？比如我们要表示字符串 i'm ok ，这时，可以用" "括起来表示：

"i'm ok"
类似的，如果字符串包含"，我们就可以用' '括起来表示：

'learn "python" in imooc'
如果字符串既包含'又包含"怎么办？

这个时候，就需要对字符串的某些特殊字符进行“转义”，python字符串用\进行转义。

要表示字符串 bob said "i'm ok".
由于 ' 和 " 会引起歧义，因此，我们在它前面插入一个\表示这是一个普通字符，不代表字符串的起始，因此，这个字符串又可以表示为

'bob said "i'm ok".'
注意：转义字符 \ 不计入字符串的内容中。

常用的转义字符还有：

\n 表示换行
\t 表示一个制表符
\ 表示 \ 字符本身

raw字符串与多行字符串

我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。例如：

r'\(~_~)/ \(~_~)/'

但是r'...'表示法不能表示多行字符串，也不能表示包含'和 "的字符串（为什么？）

如果要表示多行字符串，可以用'''...'''表示：

'''line 1
line 2
line 3'''

上面这个字符串的表示方法和下面的是完全一样的：

'line 1\nline 2\nline 3'

还可以在多行字符串前面添加 r ，把这个多行字符串也变成一个raw字符串：

r'''python is created by "guido".
it is free and easy to learn.
let's start learn python in imooc!'''

unicode字符串

转义：

u'中文\n日文\n韩文'
多行：

u'''第一行
第二行'''

raw+多行：

ur'''python的unicode字符串支持"中文",
"日文",
"韩文"等多种语言'''

整数和浮点数

布尔类型

list和tuple类型

list

按照索引访问list

倒序访问list

添加新元素

第一个办法是用 list 的 append() 方法，把新同学追加到 list 的末尾：

>>> l = ['adam', 'lisa', 'bart']
>>> l.append('paul')
>>> print l
['adam', 'lisa', 'bart', 'paul']
append()总是把新的元素添加到 list 的尾部。

方法二是用list的 insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素：

>>> l = ['adam', 'lisa', 'bart']
>>> l.insert(0, 'paul')
>>> print l
['paul', 'adam', 'lisa', 'bart']

从list删除元素

• 最后一个元素，我们可以用list的pop()方法删除：

     >>> l = ['adam', 'lisa', 'bart', 'paul']
    >>> l.pop()
    'paul'
    >>> print l
    ['adam', 'lisa', 'bart']

pop()方法总是删掉list的最后一个元素，并且它还返回这个元素，所以我们执行 l.pop() 后，会打印出 'paul'

如果paul同学不是排在最后一个怎么办？比如paul同学排在第三：

>>> l = ['adam', 'lisa', 'paul', 'bart']
要把paul踢出list，我们就必须先定位paul的位置。由于paul的索引是2，因此，用 pop(2)把paul删掉：

替换元素

替换时直接赋值

tuple

tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。

创建tuple和创建list唯一不同之处是用( )替代了[ ]。

tuple没有 append()方法，也没有insert()和pop()方法。

创建单元素tuple

包含 0 个元素的 tuple，也就是空tuple，直接用 ()表示：

>>> t = ()
>>> print t
()

创建包含1个元素的 tuple 呢？来试试：

>>> t = (1)
>>> print t
1
好像哪里不对！t 不是 tuple ，而是整数1。为什么呢？

因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。

正是因为用()定义单元素的tuple有歧义，所以 python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义：

>>> t = (1,)
>>> print t
(1,)
python在打印单元素tuple时，也自动添加了一个“,”，为了更明确地告诉你这是一个tuple。

“可变的tuple”

前面我们看到了tuple一旦创建就不能修改。现在，我们来看一个“可变”的tuple：

>>> t = ('a', 'b', ['a', 'b'])

注意到 t 有 3 个元素：'a'，'b'和一个list：['a', 'b']。list作为一个整体是tuple的第3个元素。list对象可以通过 t[2] 拿到：

>>> l = t[2]
然后，我们把list的两个元素改一改：

>>> l[0] = 'x'
>>> l[1] = 'y'

再看看tuple的内容：

>>> print t
('a', 'b', ['x', 'y'])

条件判断和循环

if语句

for循环

l = ['adam', 'lisa', 'bart']
for name in l:
    print name

### while循环

while x < n:
print x
x = x + 1

break与continue

在循环过程中，可以用break退出当前循环，还可以用continue跳过后续循环代码，继续下一次循环。

多重循环

dict和set类型

什么是dict

用 dict 表示“名字”-“成绩”的查找表如下：

d = {
    'adam': 95,
    'lisa': 85,
    'bart': 59
}

我们把名字称为key，对应的成绩称为value，dict就是通过 key 来查找 value。

花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。

访问dict

d[key] 的形式来查找对应的 value，这和 list 很像，不同之处是，list 必须使用索引返回对应的元素，而dict使用key：

注意: 通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：keyerror。

要避免 keyerror 发生，有两个办法：

• 一是先判断一下 key 是否存在，用 in 操作符：

if 'paul' in d:
    print d['paul']

如果 'paul' 不存在，if语句判断为false，自然不会执行 print d['paul'] ，从而避免了错误。

• 二是使用dict本身提供的一个 get 方法，在key不存在的时候，返回none：

>>> print d.get('bart')
59
>>> print d.get('paul')
none

dict的特点

• 查找速度快,无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

不过dict的查找速度快不是没有代价的，**dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。

• 由于dict是按 key 查找，所以，在一个dict中，key不能重复。

• 存储的key-value序对是没有顺序的！这和list不一样：

d = {
    'adam': 95,
    'lisa': 85,
    'bart': 59
}

当我们试图打印这个dict时：

>>> print d
{'lisa': 85, 'adam': 95, 'bart': 59}
打印的顺序不一定是我们创建时的顺序，而且，不同的机器打印的顺序都可能不同，这说明dict内部是无序的，不能用dict存储有序的集合。

• **是作为 key 的元素必须不可变，python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。

可以试试用list作为key时会报什么样的错误。

不可变这个限制仅作用于key，value是否可变无所谓：

{
'123': [1, 2, 3], # key 是 str，value是list
123: '123', # key 是 int，value 是 str
('a', 'b'): true # key 是 tuple，并且tuple的每个元素都是不可变对象，value是 boolean
}
最常用的key还是字符串，因为用起来最方便。

更新dict

要把新同学'paul'的成绩 72 加进去，用赋值语句：

>>> d['paul'] = 72

遍历dict

直接使用for循环可以遍历 dict 的 key：

>>> d = { 'adam': 95, 'lisa': 85, 'bart': 59 }
>>> for key in d:
...     print key
... 
lisa
adam
bart

什么是set

dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。

有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，目的就是保证这个集合的元素不会重复，这时，set就派上用场了。

set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。

所以set可以作为dict的key

访问set

访问 set中的某个元素实际上就是判断一个元素是否在set中。

例如，存储了班里同学名字的set：

`>>> s = set(['adam', 'lisa', 'bart', 'paul'])
我们可以用 **in **操作符判断：

bart是该班的同学吗？

>>> 'bart' in s
true

set的特点

• set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。

• set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。

• set存储的元素也是没有顺序的。

遍历set

由于 set 也是一个集合，所以，遍历 set 和遍历 list 类似，都可以通过 for 循环实现。

直接使用 for 循环可以遍历 set 的元素：

>>> s = set(['adam', 'lisa', 'bart'])
>>> for name in s:
...     print name
... 
lisa
adam
bart

更新set

添加元素时，用set的add()方法：

>>> s = set([1, 2, 3])
>>> s.add(4)
>>> print s
set([1, 2, 3, 4])

如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了：

>>> s = set([1, 2, 3])
>>> s.add(3)
>>> print s
set([1, 2, 3])

删除set中的元素时，用set的remove()方法：

>>> s = set([1, 2, 3, 4])
>>> s.remove(4)
>>> print s
set([1, 2, 3])

如果删除的元素不存在set中，remove()会报错：

>>> s = set([1, 2, 3])
>>> s.remove(4)
traceback (most recent call last):
  file "<stdin>", line 1, in <module>
keyerror: 4

所以用add()可以直接添加，而remove()前需要判断。

函数

什么是函数

调用函数

编写函数

返回多值

>>> r = move(100, 100, 60, math.pi / 6)
>>> print r
(151.96152422706632, 70.0)

python的函数返回多值其实就是返回一个tuple，但写起来更方便。

递归函数

汉诺塔

定义默认参数

定义可变参数

如果想让一个函数能接受任意个参数，我们就可以定义一个可变参数：

def fn(*args):
    print args

可变参数也不是很神秘，python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。

切片

对list进行切片

取前n个元素，也就是索引为0-(n-1)的元素，可以用循环：

>>> r = []
>>> n = 3
>>> for i in range(n):
...     r.append(l[i])
... 
>>> r
['adam', 'lisa', 'bart']

对这种经常取指定索引范围的操作，用循环十分繁琐，因此，python提供了切片（slice）操作符，能大大简化这种操作。

对应上面的问题，取前3个元素，用一行代码就可以完成切片：

>>> l[0:3]
['adam', 'lisa', 'bart']
l[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素

只用一个 : ，表示从头到尾：

>>> l[:]
['adam', 'lisa', 'bart', 'paul']
因此，l[:]实际上复制出了一个新list。

切片操作还可以指定第三个参数：

>>> l[::2]
['adam', 'bart']
第三个参数表示每n个取一个，上面的 l[::2] 会每两个元素取出一个来，也就是隔一个取一个。

把list换成tuple，切片操作完全相同，只是切片的结果也变成了tuple。

倒序切片

对字符串切片

字符串 'xxx'和 unicode字符串 u'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串

迭代

什么是迭代

在python中，如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们成为迭代（iteration）。

在python中，迭代是通过 for ... in 来完成的

因为 python 的 for循环不仅可以用在list或tuple上，还可以作用在其他任何可迭代对象上。

因此，迭代操作就是对于一个集合，无论该集合是有序还是无序，我们用 for 循环总是可以依次取出集合的每一个元素。

注意: 集合是指包含一组元素的数据结构，我们已经介绍的包括：

1. 有序集合：list，tuple，str和unicode；
2. 无序集合：set
3. 无序集合并且具有 key-value 对：dict
   而迭代是一个动词，它指的是一种操作，在python中，就是 for 循环。

索引迭代

**python中，迭代永远是取出元素本身，而非元素的索引。

对于有序集合，元素确实是有索引的。有的时候，我们确实想在 for 循环中拿到索引，怎么办？

方法是使用 enumerate() 函数：

>>> l = ['adam', 'lisa', 'bart', 'paul']
>>> for index, name in enumerate(l):
...     print index, '-', name
... 
0 - adam
1 - lisa
2 - bart
3 - paul

迭代dict的value

dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list，这样，我们迭代的就是 dict的每一个 value：

d = { 'adam': 95, 'lisa': 85, 'bart': 59 }
print d.values()
# [85, 95, 59]
for v in d.values():
    print v
# 85
# 95
# 59

如果仔细阅读python的文档，还可以发现，dict除了values()方法外，还有一个 itervalues() 方法，用 itervalues() 方法替代 values() 方法，迭代效果完全一样：

*那这两个方法有何不同之处呢？

1. values() 方法实际上把一个 dict 转换成了包含 value 的list。

2. 但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。

3. 打印 itervalues() 发现它返回一个 <dictionary-valueiterator> 对象，这说明在python中，for 循环可作用的迭代对象远不止 list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。

迭代dict的key和value

items() 方法把dict对象转换成了包含tuple的list，我们对这个list进行迭代，可以同时获得key和value：

>>> for key, value in d.items():
...     print key, ':', value
... 
lisa : 85
adam : 95
bart : 59

和 values() 有一个 itervalues() 类似， items() 也有一个对应的 iteritems()，iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。

列表生成式

生成列表

要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，我们可以用range(1, 11)：

>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

但如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做？方法一是循环：

>>> l = []
>>> for x in range(1, 11):
...    l.append(x * x)
... 
>>> l
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

但是循环太繁琐，而列表生成式则可以用一行语句代替循环生成上面的list：

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

这种写法就是python特有的列表生成式。利用列表生成式，可以以非常简洁的代码生成 list。

复杂表达式

假设有如下的dict：

d = { 'adam': 95, 'lisa': 85, 'bart': 59 }

完全可以通过一个复杂的列表生成式把它变成一个 html 表格：

tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name, score) for name, score in d.iteritems()]
print '<table>'
print '<tr><th>name</th><th>score</th><tr>'
print '\n'.join(tds)
print '</table>'

字符串的join()方法可以把一个 list 拼接成一个字符串

条件过滤

列表生成式的 for 循环后面还可以加上 if 判断。例如：

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

有了 if 条件，只有 if 判断为 true 的时候，才把循环的当前元素添加到列表中。

多层表达式

for循环可以嵌套，因此，在列表生成式中，也可以用多层 for 循环来生成列表。

对于字符串 'abc' 和 '123'，可以使用两层循环，生成全排列：

>>> [m + n for m in 'abc' for n in '123']
['a1', 'a2', 'a3', 'b1', 'b2', 'b3', 'c1', 'c2', 'c3']

翻译成循环代码就像下面这样：

l = []
for m in 'abc':
    for n in '123':
        l.append(m + n)

 本文的文字及图片来源于网络加上自己的想法,仅供学习、交流使用,。