python的一些基础知识

1.首先,我的python是在linux环境下编译的,windows下的暂时没弄,首先先看看linux下有python环境没，不过一般的都是自带的，没有的话安装python

1.使用包管理器:

操作系统为Debian Linux (一般都是这个系统)命令：apt-get install python

如果是Gentoo Linux 就用emerge python

2.从源文件编译

首先进入下载页面,下载源代码,下载的扩展名为.tgz的文件,放入一个位置

然后用tar xzvf解压包 解压好后进入其目录下cd Python-2.5(以2.5的为例)  

然后./configure

make

make install

然后在终端里直接输入python进入python

python较比之c来说要简洁的多,直接输入就可以输出的

#!/usr/bin/python

这个就是编译python文件的时候的头（文件都是以.py结尾的)

chmod +x *.py

写完之后要给这个文件赋予权限，x代表可执行,也可以直接给777这种，还有就是a+x这种a代表所有的用户和群组

./*.py

赋予权限后就可以执行了,还可以python *.py这样执行

交互式python解释器可以当强大的计算器使用

>>> 1-2
-1
>>> 1+2
3
>>> 3*3
9
>>> 1/2
0
>>> 1.0/2.0
0.5

python可以处理非常大的数

>>> 100000000000000000000000
100000000000000000000000L

>>> 100000000000000000000000L
100000000000000000000000L

变量

这个和其他编程语言没有任何不同，如果你从没接触过程序，相信你也很容易理解。

>>> x = 3
>>> x*2
>>> x = 5
>>> x * 2

把3 赋值给 x ，那么x 变量现在的值就是3， x 乘以 2 结果是6 ，我又把5 赋值给了 x ，那么与2相乘的结果肯定是10了。

定义变量规则：不能以数字开头，可以包含字母、数字和下划线。

语句

实际上最开始我们已经讲了语句 print 就是打印输出语句。

>>> 2*2
4

>>> print 2*2
4

行和缩进

学习Python与其他语言最大的区别就是，Python的代码块不使用大括号（{}）来控制类，函数以及其他逻辑判断。python最具特色的就是用缩进来写模块。

缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。

if True:
print "True"
else:
print "False"

获取用户输入

有使用程序运行的过程需要用户输入，根据用户输入的内容继续执行。

>>>input

>>>a = input("input:")

input:123# 输入整数

>>>raw_input(把输入当作原始数据,然后将其放入字符串中)要求用户带着引号输入他们的名字的时候就可以用这个函数

列表和元组
元组通常由不同的数据,而列表是相同的数据队列.元组表示的是结构,而列表表示的是顺序.举个例子来讲:当你想记录棋盘上一个子的坐标时，应该使用元组;当你想记录棋盘上所有的子的坐标(一系列相同的数据)时,应该使用列表

list(分片函数)通过 list(seq) 函数把一个序列类型转换成一个列表。

>>> list('hello')
['h', 'e', 'l', 'l', 'o']

del(删除)

>>> names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']
>>> del names[2]
>>> names
['Alice', 'Beth', 'Dee-Dee', 'Earl']

append(追加单个)append方法用于在列表末尾追加新的对象

>>> lst = [1, 2, 3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]

extend(追加多个)extend 方法可以在列表的末尾一次性追加另一个序列中的多个值。

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]

count(计数) count
方法统计某个元素在列表中出现的次数：

>>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to')
2
>>> x = [[1,2], 1, 1, [2, 1, [1, 2]]]
>>> x.count(1)
2
>>> x.count([1,2])
1

index(索引位置)用于从列表中找出某个值第一个匹配项的索引位置：

>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers.insert(3, 'four')
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]

insert(插入)用于将对象插入到列表中：

>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers.insert(3, 'four')
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]

pop(移除函数(默认为最后一个))pop 方法会移除列表中的一个元素（默认是最后一个），并且返回该元素的值：

>>> x = [1, 2, 3]
>>> x.pop()
3
>>> x
[1, 2]
>>> x.pop(0)
1
>>> x
[2]

remove(移除) remove 方法用于移除列表中某个值的第一个匹配项：

>>> x = ['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']
>>> x.remove('bee')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

reverse(反向存放)reverse 方法将列表中的元素反向存放。

>>> x = [1, 2, 3]
>>> x.reverse()
>>> x
[3, 2, 1]

sort(排序)sort 方法用于在原位置对列表进行排序。 

>>> x = [4, 6, 2, 1, 7, 9]
>>> x.sort()
>>> x
[1, 2, 4, 6, 7, 9]

tuple(转换元组)tuple函数的功能与list函数基本上是一样的：以一个序列作为参数并把它转化为元组。

>>> tuple([1, 2, 3])
(1, 2, 3)

find(查找 返回字串所在位置的最左端索引)

#查找字符串'dd'第一次出现的位置
>>> 'acddl123'.find('dd')
2
#查找第一次出现空格的位置
>>> 'acdd l1 23'.find(' ')
4
#指定查找的起始位置和结束位置
>>> 'acdd l1 23'.find(' ',3 ,6)
4

join(split的逆方法 将序列合成字符串)

#!/usr/bin/python

str = "-";
seq = ("a", "b", "c"); # 字符串序列
print str.join( seq );
以上实例输出结果如下：
a-b-c

>>> a = ''
>>> a.join(['1','2','3'])
123

split(join的逆方法,将字符串分割成序列)

#!/usr/bin/python

str = "Line1-abcdef \nLine2-abc \nLine4-abcd";
print str.split( );
print str.split(' ', 1 );
以上实例输出结果如下：
['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

lower(将大写字母变成小写字母)

>>>'Trondheim Hammer Dance',lower()
'trondheim hammer dance'

replace(替换字符串)

>>>'This is a test'.replace('is','eez')
'Theez eez a test'

strip(除去两边的空格)

>>> a = '     123   '
>>> a.strip()
'123'

translate(替换单个字符,可以多个替换)

#!/usr/bin/python

from string import maketrans   # 引用 maketrans 函数。

intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)

str = "this is string example....wow!!!";
print str.translate(trantab);
以上实例输出结果如下：
th3s 3s str3ng 2x1mpl2....w4w!!!

字典

clear(清除字典中所有的项)

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7};

print "Start Len : %d" %  len(dict)
dict.clear()
print "End Len : %d" %  len(dict)
以上实例输出结果为：
Start Len : 2
End Len : 0

copy(shallow copy浅复制是原本)

#!/usr/bin/python

dict1 = {'Name': 'Zara', 'Age': 7};

dict2 = dict1.copy()
print "New Dictinary : %s" %  str(dict2)
以上实例输出结果为：
New Dictinary : {'Age': 7, 'Name': 'Zara'}

copy(deep copy深复制from copy import deepcopy)

#!/usr/bin/python
# -*- coding: UTF-8 -*-

dict1 =  {'user':'runoob','num':[1,2,3]}

dict2 = dict1          # 浅拷贝: 引用对象
dict3 = dict1.copy()   # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用

# 修改 data 数据
dict1['user']='root'
dict1['num'].remove(1)

# 输出结果
print(dict1)
print(dict2)
print(dict3)
实例中 dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改。
{'num': [2, 3], 'user': 'root'}
{'num': [2, 3], 'user': 'root'}
{'num': [2, 3], 'user': 'runoob'}

fromkeys(建立新的字典值为None)

#!/usr/bin/python

seq = ('name', 'age', 'sex')

dict = dict.fromkeys(seq)
print "New Dictionary : %s" %  str(dict)

dict = dict.fromkeys(seq, 10)
print "New Dictionary : %s" %  str(dict)
以上实例输出结果为：
New Dictionary : {'age': None, 'name': None, 'sex': None}
New Dictionary : {'age': 10, 'name': 10, 'sex': 10}

get(访问字典)get() 函数返回指定键的值，如果值不在字典中返回默认值。

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 27}

print "Value : %s" %  dict.get('Age')
print "Value : %s" %  dict.get('Sex', "Never")
以上实例输出结果为：
Value : 27
Value : Never

has_key(检查是否有给出的键,如果键在字典dict里返回true，否则返回false)

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7}

print "Value : %s" %  dict.has_key('Age')
print "Value : %s" %  dict.has_key('Sex')
以上实例输出结果为：
Value : True
Value : False

items(将所有的字典以列表方式返回)

#!/usr/bin/python
# coding=utf-8

dict = {'Google': 'www.google.com', 'Runoob': 'www.runoob.com', 'taobao': 'www.taobao.com'}

print "字典值 : %s" %  dict.items()

# 遍历字典列表
for key,values in  dict.items():
print key,values
以上实例输出结果为：
字典值 : [('Google', 'www.google.com'), ('taobao', 'www.taobao.com'), ('Runoob', 'www.runoob.com')]
Google www.google.com
taobao www.taobao.com
Runoob www.runoob.com

iteritems(返回一个迭代器)

keys(将字典中的键以列表的形式返回)

>>> x = {'title':'python web site','url':'www.iplaypy.com'}
>>> x.items()
[('url', 'www.iplaypy.com'), ('title', 'python web site')]
>>> a=x.items()
>>> a
[('url', 'www.iplaypy.com'), ('title', 'python web site')]
>>> type(a)
<type 'list'>
>>> f = x.iteritems()
>>> f
<dictionary-itemiterator object at 0xb74d5e3c>
>>> type(f)
<type 'dictionary-itemiterator'>    #字典项的迭代器

iterkeys(返回针对键的迭代器)

pop(获得对应的于给定键的值,然后移除键—值)

>>>a=[1,2,3,4]
>>>print a.pop()#默认删除最后一个对象,并输出
>>>print a
4
[1,2,3]

popitem(移除随机的键—值)

#!/usr/bin/python3

site= {'name': '菜鸟教程', 'alexa': 10000, 'url': 'www.runoob.com'}
pop_obj=site.popitem()
print(pop_obj)
print(site)
输出结果为：
('url', 'www.runoob.com')
{'name': '菜鸟教程', 'alexa': 10000}

setdefault(能获得与给定键相关联的值)

#!/usr/bin/python
# -*- coding: UTF-8 -*-

dict = {'runoob': '菜鸟教程', 'google': 'Google 搜索'}

print "Value : %s" %  dict.setdefault('runoob', None)
print "Value : %s" %  dict.setdefault('Taobao', '淘宝')
以上实例输出结果为：
Value : 菜鸟教程
Value : 淘宝

update(利用一个字典更新另一个字典)

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female' }

dict.update(dict2)
print "Value : %s" %  dict
以上实例输出结果为：
Value : {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}

values(以列表的形式返回字典中的值)

#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7}

print "Value : %s" %  dict.values()
以上实例输出结果为：
Value : [7, 'Zara']

itervalues(返回字典值的迭代器)

抽象

callable(用来判断函数是否可调用)

def(创建函数)

现在就看了这么多，先整理出来了,不喜勿喷