python学习小记1

(1) Python优缺点:

优点:

1.Python有非常完善的基础代码库,覆盖了网络、文件、GUI、数据库、文本等大量内容,除了内置的库外,Python还有大量的第三方库;

2.Python应用: 首选是网络应用,包括网站、后台服务等等;其次是许多日常需要的小工具,包括系统管理员需要的脚本任务等等;另外就是把其他语言开发的程序再包装起来,方便使用.

缺点:

1. 第一个缺点就是运行速度慢,和C程序相比非常慢;

2. 第二个缺点就是代码不能加密;

(2) Python安装

采用Python2.7,下面是第一个程序:

# hello.py
print 'hello, world!'
print '100+200 =', 100+200
name = raw_input('please enter your name:')
print '------------------\n', 'hello,', name

# #################################
# print absolute value of an integer:
a = 100
if a >= 0:
    print a
else:
    print -a

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

(3)Python数据类型

1. 整数

2. 浮点数

3. 字符串:

# 转义字符\.
'I\'m \"OK\"!'
# 表示的字符串内容是:
I'm "OK"!
# 如果字符串内部有很多换行,用\n写在一行里不好阅读,为了简化,Python允许用'''...'''的格式表示多行内容
>>> print '''line1
... line2
... line3'''
# 上面是在交互式命令行内输入,如果写成程序,就是:
print '''line1
line2
line3'''

4. 布尔值: True, False;布尔值可以用andornot运算;

5. 空值: 一个特殊的值,用None表示。None不能理解为0,因为0是有意义的,而None是一个特殊的空值;

6. 变量:

在Python中,等号=是赋值语句,可以把任意数据类型赋值给变量,同一个变量可以反复赋值,而且可以是不同类型的变量;这种变量本身类型不固定的语言称之为动态语言,与之对应的是静态语言;

# a是整数
a = 123
print a
# a变为字符串
a = 'ABC'
print a

理解变量在计算机内存中的表示也非常重要。当我们写:

a = ‘ABC‘

时,Python解释器干了两件事情:

1. 在内存中创建了一个‘ABC‘的字符串;

2. 在内存中创建了一个名为a的变量,并把它指向‘ABC‘

也可以把一个变量a赋值给另一个变量b,这个操作实际上是把变量b指向变量a所指向的数据,例如下面的代码:

a = 'ABC'
b = a
a = 'XYZ'
print b

最后一行打印出变量b的内容到底是‘ABC‘呢还是‘XYZ‘?如果从数学意义上理解,就会错误地得出ba相同,也应该是‘XYZ‘,但实际上b的值是‘ABC‘,让我们一行一行地执行代码,就可以看到到底发生了什么事:

执行a = ‘ABC‘,解释器创建了字符串‘ABC‘和变量a,并把a指向‘ABC‘

执行b = a,解释器创建了变量b,并把b指向a指向的字符串‘ABC‘

执行a = ‘XYZ‘,解释器创建了字符串‘XYZ‘,并把a的指向改为‘XYZ‘,但b并没有更改:

所以,最后打印变量b的结果自然是‘ABC‘了。

7. 常量

所谓常量就是不能变的变量,比如常用的数学常数π就是一个常量。在Python中,通常用全部大写的变量名表示常量:

PI = 3.14159265359

但事实上PI仍然是一个变量,Python根本没有任何机制保证PI不会被改变,所以,用全部大写的变量名表示常量只是一个习惯上的用法,如果你一定要改变变量PI的值,也没人能拦住你。

最后解释一下整数的除法为什么也是精确的,可以试试:

>>> 10 / 3
3

你没有看错,整数除法永远是整数,即使除不尽。要做精确的除法,只需把其中一个整数换成浮点数做除法就可以:

>>> 10.0 / 3
3.3333333333333335

因为整数除法只取结果的整数部分,所以Python还提供一个余数运算,可以得到两个整数相除的余数:

>>> 10 % 3
1

无论整数做除法还是取余数,结果永远是整数,所以,整数运算结果永远是精确的。

(4) 字符串和编码

1. ASCII编码和Unicode编码的区别:ASCII编码是1个字节,而Unicode编码通常是2个字节。

字母A用ASCII编码是十进制的65,二进制的01000001

字符0用ASCII编码是十进制的48,二进制的00110000,注意字符‘0‘和整数0是不同的;

汉字已经超出了ASCII编码的范围,用Unicode编码是十进制的20013,二进制的01001110 00101101

你可以猜测,如果把ASCII编码的A用Unicode编码,只需要在前面补0就可以,因此,A的Unicode编码是00000000 01000001

新的问题又出现了:如果统一成Unicode编码,乱码问题从此消失了。但是,如果你写的文本基本上全部是英文的话,用Unicode编码比ASCII编码需要多一倍的存储空间,在存储和传输上就十分不划算。

所以,本着节约的精神,又出现了把Unicode编码转化为“可变长编码”的UTF-8编码。UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节,常用的英文字母被编码成1个字节,汉字通常是3个字节,只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符,用UTF-8编码就能节省空间:

字符 ASCII Unicode UTF-8
A 01000001 00000000 01000001 01000001
x 01001110 00101101 11100100 10111000 10101101

2. 在计算机内存中,统一使用Unicode编码,当需要保存到硬盘或者需要传输的时候,就转换为UTF-8编码。

用记事本编辑的时候,从文件读取的UTF-8字符被转换为Unicode字符到内存里,编辑完成后,保存的时候再把Unicode转换为UTF-8保存到文件:

浏览网页的时候,服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器:

所以你看到很多网页的源码上会有类似<meta charset="UTF-8" />的信息,表示该网页正是用的UTF-8编码。

3. Python提供了ord()和chr()函数,可以把字母和对应的数字相互转换:

>>> ord('A')
65
>>> chr(65)
'A'

4. 把u‘xxx‘转换为UTF-8编码的‘xxx‘encode(‘utf-8‘)方法:

>>> u‘ABC‘.encode(‘utf-8‘)
‘ABC‘
>>> u‘中文‘.encode(‘utf-8‘)
‘\xe4\xb8\xad\xe6\x96\x87‘

5. 反过来,把UTF-8编码表示的字符串‘xxx‘转换为Unicode字符串u‘xxx‘decode(‘utf-8‘)方法:

>>> ‘abc‘.decode(‘utf-8‘)
u‘abc‘
>>> ‘\xe4\xb8\xad\xe6\x96\x87‘.decode(‘utf-8‘)
u‘\u4e2d\u6587‘
>>> print ‘\xe4\xb8\xad\xe6\x96\x87‘.decode(‘utf-8‘)
中文

6. 由于Python源代码也是一个文本文件,所以,当你的源代码中包含中文的时候,在保存源代码时,就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时,为了让它按UTF-8编码读取,我们通常在文件开头写上这两行:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

第一行注释是为了告诉Linux/OS X系统,这是一个Python可执行程序,Windows系统会忽略这个注释;

第二行注释是为了告诉Python解释器,按照UTF-8编码读取源代码,否则,你在源代码中写的中文输出可能会有乱码。

7. 格式化字符串的方式

# %d	整数
# %f	浮点数
# %s	字符串
# %x	十六进制整数
# 如果只有一个%?,括号可以省略
print 'Hello, %s' % 'world'
print 'Hi, %s, you have $%d.' % ('xiaotian', 1000000)
print '%10d-%08d' % (3, 1)
print '%.4f' % 3.1415926
# 用%%来表示一个%
print 'growth rate: %d%%' % 7
# 对于Unicode字符串,用法完全一样
print u'Hi, %s' % u'xiaotian'

(5) list和tuple

Python内置的一种数据类型是列表:list。list是一种有序的集合,可以随时添加和删除其中的元素:

>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
# ['Michael', 'Bob', 'Tracy']
# 变量classmates就是一个list。用len()函数可以获得list元素的个数:
>>> len(classmates)
# 3
# 用索引来访问list中每一个位置的元素,记得索引是从0开始的:
>>> classmates[0]
# 'Michael'
# 记得最后一个元素的索引是len(classmates) - 1。
# 如果要取最后一个元素,除了计算索引位置外,还可以用-1做索引,直接获取最后一个元素:
>>> classmates[-1]
# 'Tracy'
# 以此类推,可以获取倒数第2个、倒数第3个:
>>> classmates[-2]
# 'Bob'
# list是一个可变的有序表,所以,可以往list中追加元素到末尾:
>>> classmates.append('Adam')
>>> classmates
# ['Michael', 'Bob', 'Tracy', 'Adam']
# 也可以把元素插入到指定的位置,比如索引号为1的位置:
>>> classmates.insert(1, 'Jack')
>>> classmates
# ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
# 要删除list末尾的元素,用pop()方法:
>>> classmates.pop()
# 'Adam'
>>> classmates
# ['Michael', 'Jack', 'Bob', 'Tracy']
# 要删除指定位置的元素,用pop(i)方法,其中i是索引位置:
>>> classmates.pop(1)
# 'Jack'
>>> classmates
# ['Michael', 'Bob', 'Tracy']
# 要把某个元素替换成别的元素,可以直接赋值给对应的索引位置:
>>> classmates[1] = 'Sarah'
>>> classmates
# ['Michael', 'Sarah', 'Tracy']
# list里面的元素的数据类型也可以不同,比如:
>>> L = ['Apple', 123, True]
# list元素也可以是另一个list,比如:
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
# 4
# 要注意s只有4个元素,其中s[2]又是一个list,如果拆开写就更容易理解了:
>>> p = ['asp', 'php']
>>> s = ['python', 'java', p, 'scheme']
# 要拿到'php'可以写p[1]或者s[2][1],因此s可以看成是一个二维数组,类似的还有三维、四维……数组,不过很少用到。
# 如果一个list中一个元素也没有,就是一个空的list,它的长度为0:
>>> L = []
>>> len(L)
# 0

tuple

另一种有序列表叫元组:tuple。tuple和list非常类似,但是tuple一旦初始化就不能修改,比如同样是列出同学的名字:

>>> classmates = ('Michael', 'Bob', 'Tracy')
# 现在,classmates这个tuple不能变了,它也没有append(),insert()这样的方法。其他获取元素的方法和list是一样的,你可以正常地使用classmates[0],classmates[-1],但不能赋值成另外的元素。
# 不可变的tuple有什么意义?因为tuple不可变,所以代码更安全。如果可能,能用tuple代替list就尽量用tuple。
# tuple的陷阱:当你定义一个tuple时,在定义的时候,tuple的元素就必须被确定下来,比如:
>>> t = (1, 2)
>>> t
# (1, 2)
# 如果要定义一个空的tuple,可以写成():
>>> t = ()
>>> t
# ()
# 但是,要定义一个只有1个元素的tuple,如果你这么定义:
>>> t = (1)
>>> t
# 1
# 定义的不是tuple,是1这个数!这是因为括号()既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是1。
# 所以,只有1个元素的tuple定义时必须加一个逗号,,来消除歧义:
>>> t = (1,)
>>> t
# (1,)
# Python在显示只有1个元素的tuple时,也会加一个逗号,,以免你误解成数学计算意义上的括号。
# 最后来看一个“可变的”tuple:
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
# ('a', 'b', ['X', 'Y'])

这个tuple定义的时候有3个元素,分别是‘a‘‘b‘和一个list。不是说tuple一旦定义后就不可变了吗?怎么后来又变了?

别急,我们先看看定义的时候tuple包含的3个元素:

当我们把list的元素‘A‘‘B‘修改为‘X‘‘Y‘后,tuple变为:

表面上看,tuple的元素确实变了,但其实变的不是tuple的元素,而是list的元素。tuple一开始指向的list并没有改成别的list,所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向‘a‘,就不能改成指向‘b‘,指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!

(6) 条件判断和循环

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

if语句执行有个特点,它是从上往下判断,如果在某个判断上是True,把该判断对应的语句执行后,就忽略掉剩下的elifelse,所以,请测试并解释为什么下面的程序打印的是teenager

age = 20
if age >= 6:
    print ‘teenager‘
elif age >= 18:
    print ‘adult‘
else:
    print ‘kid‘

循环

Python的循环有两种,一种是for...in循环,依次把list或tuple中的每个元素迭代出来,看例子:

names = [‘Michael‘, ‘Bob‘, ‘Tracy‘]
for name in names:
    print name

执行这段代码,会依次打印names的每一个元素.for x in ...循环就是把每个元素代入变量x,然后执行缩进块的语句。

range(101)就可以生成0-100的整数序列,计算如下:

sum = 0
for x in range(101):
    sum = sum + x
print sum

第二种循环是while循环,只要条件满足,就不断循环,条件不满足时退出循环。比如我们要计算100以内所有奇数之和,可以用while循环实现:

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print sum

在循环内部变量n不断自减,直到变为-1时,不再满足while条件,循环退出。

最后看一个有问题的条件判断。很多同学会用raw_input()读取用户的输入,这样可以自己输入,程序运行得更有意思:

birth = raw_input(‘birth: ‘)
if birth < 2000:
    print ‘00前‘
else:
    print ‘00后‘

输入1982,结果却显示00后,这么简单的判断Python也能搞错?

当然不是Python的问题,在Python的交互式命令行下打印birth看看:

>>> birth
‘1982‘
>>> ‘1982‘ < 2000
False
>>> 1982 < 2000
True

原因找到了!原来从raw_input()读取的内容永远以字符串的形式返回,把字符串和整数比较就不会得到期待的结果,必须先用int()把字符串转换为我们想要的整型:

birth = int(raw_input(‘birth: ‘))

再次运行,就可以得到正确地结果。当然了,输入的数据是要可以转换成数字的.

(7) 使用dict和set

dict

Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度。由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉:

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
# 95
>>> d['Jack'] = 90
>>> d['Jack']
# 90
>>> d['Jack'] = 88
>>> d['Jack']
# 88

如果key不存在,dict就会报错. 要避免key不存在的错误,有两种办法,一是通过in判断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中删除:

>>> d.pop(‘Bob‘)
75
>>> d
{‘Michael‘: 95, ‘Tracy‘: 85}

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

和list比较,dict有以下几个特点:

  1. 查找和插入的速度极快,不会随着key的增加而增加;
  2. 需要占用大量的内存,内存浪费多。

而list相反:

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

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

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

set

set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。

要创建一个set,需要提供一个list作为输入集合:

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

注意,传入的参数[1, 2, 3]是一个list,而显示的set([1, 2, 3])只是告诉你这个set内部有1,2,3这3个元素,显示的[]不表示这是一个list。

重复元素在set中自动被过滤:

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

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

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

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

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

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

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
set([2, 3])
>>> s1 | s2
set([1, 2, 3, 4])

set和dict的唯一区别仅在于没有存储对应的value,但是,set的原理和dict一样,所以,同样不可以放入可变对象,因为无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”。试试把list放入set,看看是否会报错。

再议不可变对象

上面我们讲了,str是不变对象,而list是可变对象。

对于可变对象,比如list,对list进行操作,list内部的内容是会变化的,比如:

>>> a = [‘c‘, ‘b‘, ‘a‘]
>>> a.sort()
>>> a
[‘a‘, ‘b‘, ‘c‘]

而对于不可变对象,比如str,对str进行操作呢:

>>> a = ‘abc‘
>>> a.replace(‘a‘, ‘A‘)
‘Abc‘
>>> a
‘abc‘

虽然字符串有个replace()方法,也确实变出了‘Abc‘,但变量a最后仍是‘abc‘,应该怎么理解呢?

我们先把代码改成下面这样:

>>> a = ‘abc‘
>>> b = a.replace(‘a‘, ‘A‘)
>>> b
‘Abc‘
>>> a
‘abc‘

要始终牢记的是,a是变量,而‘abc‘才是字符串对象!有些时候,我们经常说,对象a的内容是‘abc‘,但其实是指,a本身是一个变量,它指向的对象的内容才是‘abc‘

当我们调用a.replace(‘a‘, ‘A‘)时,实际上调用方法replace是作用在字符串对象‘abc‘上的,而这个方法虽然名字叫replace,但却没有改变字符串‘abc‘的内容。相反,replace方法创建了一个新字符串‘Abc‘并返回,如果我们用变量b指向该新字符串,就容易理解了,变量a仍指向原有的字符串‘abc‘,但变量b却指向新字符串‘Abc‘了:

所以,对于不变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。相反,这些方法会创建新的对象并返回,这样,就保证了不可变对象本身永远是不可变的。

[截自]http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000

时间: 2024-10-27 00:30:52

python学习小记1的相关文章

python学习小记

python画的图表不能显示中文的时候,使用下面的代码可以解决这个问题: import matplotlib matplotlib.use('qt4agg') #指定默认字体 matplotlib.rcParams['font.sans-serif'] = ['SimHei'] matplotlib.rcParams['font.family']='sans-serif' 画曲线的代码: import numpy as np import matplotlib.pyplot as plt fro

python学习小记01--萌新的进化

1.英文缩写 比如换行\n代表[+newline]:退格\b代表[+backspace]:回车\r代表[+return].大家可以按照这种方法记住转义字符的含义 整数,整数英文为integer,简写做int整数,整数英文为integer,简写做int str代表字符串,全称为string,整数的英文简称为int,全称为integer. 2.= 和 == 代码世界中,赋值符号=不是左边等于右边的意思.仅仅表示赋值动作:把右边的内容放到了左边的盒子中. 3. 整数 而整数脱掉了[引号]马甲,只能『单

Python学习小记(2)---[list, iterator, and, or, zip, dict.keys]

1.List行为 可以用 alist[:] 相当于 alist.copy() ,可以创建一个 alist 的 shallo copy,但是直接对 alist[:] 操作却会直接操作 alist 对象 >>> alist = [1,2,3] >>> blist = alist[:] #assign alist[:] to blist >>> alist [1, 2, 3] >>> blist [1, 2, 3] >>>

linux学习小记 (一 )

shell 学习小记: 注意:多看系统脚本  多模仿    su切换用户时需要输入目标用户密码,root(superuser)切换到任何用户都不需要输入密码,- 参数必须要是最后一个(su huhu -) sudo需要输入当前用户密码,拥有sudo特权的用户可以执行 "sudo su -"命令,使用自己的密码切换到root用户 , 所以应该在/etc/sudoers 文件中禁止 sudo 执行su命令 linux文件与颜色: /etc/DIR_COLORS   (命令dircolors

python学习:程序控制结构·作业20141219

Python学习:程序控制结构 20141219 编程环境: windows 7 x64 python 2.7.6 题目: 1 编写程序,完成下列题目(1分) 题目内容: 如果列出10以内自然数中3或5的倍数,则包括3,5,6,9.那么这些数字的和为23.要求计算得出任意正整数n以内中3或5的倍数的自然数之和. 输入格式: 一个正整数n. 输出格式: n以内中3或5的倍数的自然数之和. 输入样例: 10 输出样例: 23 时间限制:500ms内存限制:32000kb n = int(raw_in

python学习第二天

python学习的第二天就是个灾难啊,这天被打击了,自己写的作业被否认了,不说了,写博客还是个好习惯的,要坚持下去,就不知道能坚持到什么时候.呵呵!!! 这天教的知识和第一天的知识相差不大,区别在于比第一天讲的更细了(我们是两个老师教的,风格是不一样的),这次也写那些比较细的知识点. python的简介 (1)你的程序一定要有个主文件. (2)对于python,一切事物都是对象,对象基于类创建.#似懂非懂,不过有那么点似懂. 知识点 #__divmod__ 会把两个数字相除的商和余数以元组的方式

git 学习小记之记住https方式推送密码

昨天刚刚学了点git基础操作,但是不幸的是[email protected]给出公告说尽量使用 https 进行操作.可是在用 https 进行 push 时,都需要输入帐号和密码. 各种百度谷歌之后在[email protected]官网找到了解决方法<https方式使用[email protected]设置密码的方式>文中给出了几个方法,并且都非常简单. 关于 cache 缓存方式,我不太喜欢,因为要设置时间,而且会过期.而 store 相应的非常方便,设置全局后,方便多个库使用.当然如果

[Python 学习] 二、在Linux平台上使用Python

这一节,主要介绍在Linux平台上如何使用Python 1. Python安装. 现在大部分的发行版本都是自带Python的,所以可以不用安装.如果要安装的话,可以使用对应的系统安装指令. Fedora系统:先以root登入,运行 yum install python Ubuntu系统:在root组的用户, 运行 sudo apt-get install python 2. 使用的Python的脚本 Linux是一个以文件为单位的系统,那么我们使用的Python是哪一个文件呢? 这个可以通过指令

python学习之最简单的用户注册及登录验证小程序

文章都是从我的个人博客上粘贴过来的哦,更多内容请点击 http://www.iwangzheng.com 正如很多同学所知道的,楼主开始学习python了,前进的道路曲曲折折,有荆棘也有陷阱,从最简单的小程序写起,每天练习,将python进行到底. 有一点比较别扭的就是python的换行之后空四个空格,ruby都是两个,并且python在方法和循环语句的第一句都要加冒号 mysql> show create table user; mysql> alter table user add sal