Python学习笔记-基础

发表于 | 分类于 | 热度 | 字数统计 3,036

一起愉快的学Py吧，早就听说Py的大名了，感觉还并不是太难，只是一时心血来潮，一直有个梦想，写个爬虫去爬那个啥….o(￣▽￣)ゞ))￣▽￣)o

开始

py作为解释性语言，能够很好的被读懂(大概)，一向是以简洁 优雅著称
因为是解释执行，不会进行预编译成二进制文件，所以….代码是不能被加密的，发就发源代码了…
还有一点在py中是不建议使用分号用来结尾的，都是以缩进(四个空格)来区分代码的范围

Py文件的头一般有这两句：

1
2
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；
第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

数据类型和变量

因为有java语言的基础，主要总结下与java不同的地方

字符串

如果字符串中有太多的转义字符可以在前面加r这样里面就不需要进行转义了r'字符串内容'
如果需要很多的换行符，为了简便可以使用'''...'''，在里面回车会被记录，不用再写转义\n，注意在输入多行内容时，提示符由>>>变为...，提示你可以接着上一行输入。
多行字符串'''...'''还可以在前面加上r使用。

1
2
3
4
5
6
>>> print('''line1
... line2
... line3''')
line1
line2
line3

布尔类型

一个布尔值只有True、False两种值，注意第一个字母是大写的，布尔值可以用and、or和not运算(类似与或非运算吧…)。
Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True

  • 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。
  • 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。

空值

空值是Python里一个特殊的值，用None表示。和java中的null类似

关于除法

用/进行运算的除法得到的是一个浮点数，即使两个整数相除
还有一种除法是//，称为地板除，两个整数的除法仍然是整数，会舍弃小数部分

python的整数和浮点数没有大小限制！

循环

和JS中类似，Py中的for循环只有for…in的形式，比如经典问题：计算1+2+…+100：

1
2
3
4
5
# range(101)就可以生成0-100的整数序列
sum = 0
for x in range(101):
    sum = sum + x
print(sum)

还有另一种循环while，这个就变化不大了，只要条件满足，就不断循环：

1
2
3
4
5
6
sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

还有break 和 continue也是一样的

条件判断

py中的if确实和java之类不太一样，简化了不少，也不需要加括号，不过要注意:的问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
age = 3
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')

# input()能够获取用户的输入，接受的一个str用于提示用户
# 获取的内容都会转成str类型，需要什么类型的要相对应强转下
s = input('birth: ')
birth = int(s)
if birth < 2000:
    print('00前')
else:
    print('00后')

list和tuple

我认为py中的集合类的类型显得更加重要，很多神奇的操作都发生在这里。o(￣▽￣)ゞ))￣▽￣)o

list

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
感觉挺像数组的，因为是动态引用，所以里面的元素没有类型的限制，并且list[-1]可以表示最后一个元素，以此类推

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# list的定义，用中括号定义
a = [1,]

# 通过append方法向list尾部添加元素
a.append('Adam')

# 把元素插入到指定位置，pos为索引
a.insert(1, 'Jack')

# 删除末尾元素,并且会返回这个元素
# 并且它可以接受一个索引参数，删除指定索引的元素
a.pop()

# 替换元素可以直接进行赋值
a[0] = 123

# list中可以再存list，类似二维数组
s = ['python', 'java', ['asp', 'php'], 'scheme']

当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates) - 1。

tuple

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改
它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的
不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

1
2
3
4
5
6
7
# 定义tuple使用小括号(),当只有一个元素时，为了避免产生歧义当作小括号进行运算，我们一般会在后面加个,
t = (1,)

# 定义一个“可变”的tuple
# 可以看作其中的list是引用数据类型，t[2]指向的是list的地址，而list是可变的
# t指向的list并没有改变所以可以认为tuple确实是不可修改的
t = ('a', 'b', ['A', 'B'])

dict和set

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。
为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。
第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。如上
它们都是无序的，获取的时候不能使用下标的方式

dict

dict就是第二种实现方式，基本的使用(使用{}花括号来定义)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

# 我们还可以通过key进行赋值，重复赋值会被覆盖
>>> d['Adam'] = 67
>>> d['Adam']
67

# 获取的时候如果key不存在就会报错，为了避免可以判断下
>>> 'Thomas' in d
False

# 通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value
>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1

注意：返回None的时候Python的交互式命令行不显示结果。
要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

1
2
3
4
>>> d.pop('Bob')
75
>>> d
{'Michael': 95, 'Tracy': 85}

请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较，dict有以下几个特点：

  1. 查找和插入的速度极快，不会随着key的增加而变慢；
  2. 需要占用大量的内存，内存浪费多。
  3. key不能重复，同时存储的键值对是没有顺序的
  4. 作为Key的元素必须是不可变的

而list相反：

  1. 查找和插入的时间随着元素的增加而增加；
  2. 占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。

这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。

要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：

1
2
3
4
5
>>> key = [1, 2, 3]
>>> d[key] = 'a list'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

set

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，可以保证没有重复的元素(key)。
要创建一个set，需要提供一个list作为输入集合：

1
2
3
>>> s = set([1, 2, 3])
>>> s
{1, 2, 3} # 没有values

注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的(它其实是无序的)。。
重复元素在set中自动被过滤：

1
2
3
>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}

通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：

1
2
3
4
5
6
7
>>> s.add(4)
>>> s
{1, 2, 3, 4}

>>> s.add(4)
>>> s
{1, 2, 3, 4}

通过remove(key)方法可以删除元素：

1
2
3
>>> s.remove(4)
>>> s
{1, 2, 3}

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

1
2
3
4
5
6
7
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}

>>> s1 | s2
{1, 2, 3, 4}

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。
set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。
关于更新，由于set存储的是一组不重复的无序元素，因此，更新set主要做两件事：
一是把新的元素添加到set中，二是把已有元素从set中删除。
set拥有 add remove 方法
同样可以使用'name' in set来进行判断是否存在
最后，set存储的元素也是没有顺序的。

关于可变与不可变的补充

tuple虽然是不变对象，上面也解释过，可以把list当作是一个引用，(1, [2, 3])可以看作是不变的，但如果把(1, 2, 3)和(1, [2, 3])放入dict或set中，是会报错的，即使引用不会变，但list的内容可变，根据dict和set的规定，同样会导致哈希化的失败

其他补充

连接符

,相当于空格、分隔符的作用来连接两个字符串
print 'aaa',123

关于编码

str.decode("UTF-8") 解码
str.encode("UTF-8") 编码
b'aaa' bytes类型，一个字符占一个字节

格式化输出

1
2
>>> '%.2f' % 3.1415926
'3.14'

%其实可以看作是占位符print('%s' % 'abc')

数据类型

Python3 中有六个标准的数据类型：

  1. Number（数字）
  2. String（字符串）
  3. List（列表）
  4. Tuple（元组）
  5. Sets（集合）
  6. Dictionary（字典）

重新赋值

1
2
a = 'abc'
a = 'def'

原来的值如果没有别的变量引用，就会被垃圾回收，但是无法预测回收时间，多久回收一次由V8引擎自己决定

更多

待补充…

喜欢就请我吃包辣条吧！

评论框加载失败，无法访问 Disqus

你可能需要魔法上网~~