python基础

待实验的问题：

Python：

一、简单说明：

1 他注重的是如何解决问题而不是语法和结构。

 2 内存管理器：CC++最大的弊病在于内存管理是由程序员负责的。在Python内存管理是由Python解释器负责的。

3 Python是一种解释性的语言，这意味着开发过程中没有编译这个环节，他实际上是字节编译的，其结果是生成一种近似机器语言的中间形式。所以他不是以本地机器码运行的，所以解释性语言通常比编译型运行的慢。

4 核心风格：缩进使用4个空格的宽度，避免使用制表符（如果代码会被跨平台应用，不同文本编辑器带表的空白宽度不同，如果不跨平台的话我还是用制表符）

二、基本内容：

1 note 

python hello.py 或者 #! /usr/bin/python 告诉系统执行程序的时候使用哪个编译器

2 字符串

使用单引号（'）使用双引号（"）完全相同
使用三引号（'''或"""）

利用三引号，你可以指示一个多行的字符串。

你可以在三引号中自由的使用单引号和双引号。你也可以在双引号中自由使用单引号。你也可以在单引号中自由的使用双引号。

转义符

假设你想要在一个字符串中包含一个单引号（'），字符串表示为'What\'s your name?'。

另一个表示这个特别的字符串的方法是"What's your name?"，即用双引号。类似地，要在双引号字符串中使用双引号本身的时候，也可以借助于转义符。另外，你可以用转义符\\来指示反斜杠本身。

值得注意的一件事是，在一个字符串中，行末的单独一个反斜杠表示字符串在下一行继续，而不是开始一个新的行。例如：

"This is the first sentence.\
This is the second sentence."

等价于"This is the first sentence. This is the second sentence."

自然字符串

如果你想要指示某些不需要如转义符那样的特别处理的字符串，那么你需要指定一个自然字符串。自然字符串通过给字符串加上前缀r或R来指定。例如r"Newlines are indicated by \n"。

Unicode字符串

Unicode是书写国际文本的标准方法。如果你想要用你的母语如北印度语或阿拉伯语写文本，那么你需要有一个支持Unicode的编辑器。类似地，Python允许你处理Unicode文本——你只需要在字符串前加上前缀u或U。例如，u"This is a Unicode string."。

记住，在你处理文本文件的时候使用Unicode字符串，特别是当你知道这个文件含有用非英语的语言写的文本。

3、内建函数

raw_input:

guess = int(raw_input('Enter an integer : ')) 与 c语言中的scanf("%d", s); 。而int（）类型转换 与 %d 的作用是一样的。

range:

默认地，range的步长为1。如果我们为range提供第三个数，那么它将成为步长。例如，range(1,5,2)给出[1,3]。记住，range 向上 延伸到第二个数，即它不包含第二个数。

len:

s = raw_input('Enter something : ')


l = len(s)

print:

print 'you get the num ', num

print 'you get the num %d', %num

print ‘you get the num %d from %s', %(num, str)

print 'you get the num',取消换行




4、控制流

if语句：

if guess == number:

print "Get It!"

else:

print "Not Get It!"

while语句:

while running:

break 或者

continue

for语句:

for i in range(1, 5):

break 或者

continue

值得注意的是：在while 和 for 与 else 搭配使用的时候，如果循环里有break，那么一旦执行break，会跳出循环并且也跳过else。

5、函数

定义函数：

def sayHello(a, b = 1): #如果实参没有给b传人，那么b就等于默认值1

global x #全局的变量

x = a + b
    print 'x is ', x

x = 3 

sayHello(1)

print 'value x is ', x


sayHello(1, 2)

print 'value x is ', x

命令行输入参数

import sys


print 'The command line arguments are:'
for i in sys.argv:
    print i


当执行python sys_argv.py hello world时打印输出：

The command line arguments are:

sys_argv.py

hello

world

6、文档字符串  docstrings

def printMax(x, y):
    '''Prints the maximum of two numbers.

    The two values must be integers.'''
    x = int(x) # convert to integers, if possible
    y = int(y)

    if x > y:
        print x, 'is maximum'
    else:
        print y, 'is maximum'

printMax(3, 5)
print printMax.__doc__    这个就相当于我们经常用的help（printMax）命令

7、模块

创建自己的模块：

#!/usr/bin/python
# Filename: mymodule.py

def sayhi():
    print 'Hi, this is mymodule speaking.'

version = '0.1'

# End of mymodule.py


使用创建的模块，两种方法使用创建的模块：

一个模块就相当于一个.py文件

Method1:

#!/usr/bin/python
# Filename: mymodule_demo.py

import mymodule

mymodule.sayhi()
print 'Version', mymodule.version

Method2:

#!/usr/bin/python
# Filename: mymodule_demo2.py
import mymodule
from mymodule import sayhi, version
# Alternative:
# from mymodule import *

sayhi()
print 'Version', version


8、数据结构

列表：需要特别注意的是，以下操作直接影响列表的本身

shoplist = ['apple', 'mango', 'carrot', 'banana']

shoplist.append('rice')


del shoplist[0]

元组：元组和列表十分类似，只不过元组和字符串一样是 不可变的 即你不能修改元组。元组通过圆括号中用逗号分割的项目定义。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组的值不会改变。

列表和元组可以使用索引和切片操作符。举例：

shoplist = ['apple', 'mango', 'carrot', 'banana']

'apple'是位置0， 'mango'是位置1，'carrot'是位置2， 'banana'是位置3也可以用-1表示（最后一个）

shoplist[1:-1] 返回除了最后一个表示从位置1开始到位置-1结束但是不包括位置-1

shoplist[1:]返回从位置1开始到最后一个结束包括最后一个

字典：键（必须为不可变对象）和 值

ab = {       'Swaroop'   : 'swaroopch@byteofpython.info',
             'Larry'     : 'larry@wall.org',
             'Matsumoto' : 'matz@ruby-lang.org',
             'Spammer'   : 'spammer@hotmail.com'
     }

print "Swaroop's address is %s" % ab['Swaroop']

ab['Guido'] = 'guido@python.org'

del ab['Spammer']

for name, address in ab.items():
    print 'Contact %s at %s' % (name, address)

if 'Guido' in ab: # OR ab.has_key('Guido')
    print "\nGuido's address is %s" % ab['Guido']




shoplist = ['a', 'b', 'c']

mylist = shoplist #这么干相当于C语言中的指针指向啦，指向相同的内存


mylist = shoplist[:] #这么干相当于C语言中给mylist指向的内存中copy shoplist指向内存中的内容

如果：

del shoplist[0] 


第一种情况：print shoplist, '\n', mylist  

['b', 'c']'

['b', 'c']

第二种情况：print shoplist, '\n', mylist

['b', 'c']

['a', 'b', 'c']

字符串的更多内容：

可以测试字符串是否以某个字符串开始，或则是否包含某个字符串。

8、面向对象的编程

类和对象是面向对象编程的两个主要方面。类创建一个新类型，而对象这个类的 实例 。

class Person:
    population = 0

    def __init__(self, name):
        self.name = name#self.name定义了一个对象的变量
        print '(Initializing %s)' % self.name

        Person.population += 1

    def __del__(self):
        print '%s says bye.' % self.name

    def sayHi(self):#类的方法和普通函数有一个特别的区别，必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值
       if Person.population == 1#类的变量，所有这个类的对象共享这个变量

       print 'the first one say Hi'

  if Person.population == 1

print 'the second one say Hi'

继承：

class SchoolMember:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        print '(Initialized SchoolMember: %s)' % self.name

    def tell(self):
        '''Tell my details.'''
        print 'Name:"%s" Age:"%s"' % (self.name, self.age),

class Teacher(SchoolMember):#继承基类
    def __init__(self, name, age, salary):
        SchoolMember.__init__(self, name, age)
        self.salary = salary
        print '(Initialized Teacher: %s)' % self.name

    def tell(self):
        SchoolMember.tell(self)
        print 'Salary: "%d"' % self.salary
特别注意的是在子类中重用基类代码的时候，要把子类self（也就是那个对象）传递给基类。（当你调用这个对象的方法MyObject.method(arg1, arg2)的时候，这会由Python自动转为MyClass.method(MyObject, arg1, arg2)——这就是self的原理了。）

未完待续：开始Django学习

   

       

表5.1 运算符与它们的用法

运算符	名称	说明	例子
+	加	两个对象相加	3 + 5得到8。'a' + 'b'得到'ab'。
-	减	得到负数或是一个数减去另一个数	-5.2得到一个负数。50 - 24得到26。
*	乘	两个数相乘或是返回一个被重复若干次的字符串	2 * 3得到6。'la' * 3得到'lalala'。
**	幂	返回x的y次幂	3 ** 4得到81（即3 * 3 * 3 * 3）
/	除	x除以y	4/3得到1（整数的除法得到整数结果）。4.0/3或4/3.0得到1.3333333333333333
//	取整除	返回商的整数部分	4 // 3.0得到1.0
%	取模	返回除法的余数	8%3得到2。-25.5%2.25得到1.5
<<	左移	把一个数的比特向左移一定数目（每个数在内存中都表示为比特或二进制数字，即0和1）	2 << 2得到8。——2按比特表示为10
>>	右移	把一个数的比特向右移一定数目	11 >> 1得到5。——11按比特表示为1011，向右移动1比特后得到101，即十进制的5。
&	按位与	数的按位与	5 & 3得到1。
|	按位或	数的按位或	5 | 3得到7。
^	按位异或	数的按位异或	5 ^ 3得到6
~	按位翻转	x的按位翻转是-(x+1)	~5得到6。
<	小于	返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。	5 < 3返回0（即False）而3 < 5返回1（即True）。比较可以被任意连接：3 < 5 < 7返回True。
>	大于	返回x是否大于y	5 > 3返回True。如果两个操作数都是数字，它们首先被转换为一个共同的类型。否则，它总是返回False。
<=	小于等于	返回x是否小于等于y	x = 3; y = 6; x <= y返回True。
>=	大于等于	返回x是否大于等于y	x = 4; y = 3; x >= y返回True。
==	等于	比较对象是否相等	x = 2; y = 2; x == y返回True。x = 'str'; y = 'stR'; x == y返回False。x = 'str'; y = 'str'; x == y返回True。
!=	不等于	比较两个对象是否不相等	x = 2; y = 3; x != y返回True。
not	布尔“非”	如果x为True，返回False。如果x为False，它返回True。	x = True; not y返回False。
and	布尔“与”	如果x为False，x and y返回False，否则它返回y的计算值。	x = False; y = True; x and y，由于x是False，返回False。在这里，Python不会计算y，因为它知道这个表达式的值肯定是False（因为x是False）。这个现象称为短路计算。
or	布尔“或”	如果x是True，它返回True，否则它返回y的计算值。	x = True; y = False; x or y返回True。短路计算在这里也适用。

---

表5.2 运算符优先级

运算符	描述
lambda	Lambda表达式
or	布尔“或”
and	布尔“与”
not x	布尔“非”
in，not in	成员测试
is，is not	同一性测试
<，<=，>，>=，!=，==	比较
|	按位或
^	按位异或
&	按位与
<<，>>	移位
+，-	加法与减法
*，/，%	乘法、除法与取余
+x，-x	正负号
~x	按位翻转
**	指数
x.attribute	属性参考
x[index]	下标
x[index:index]	寻址段
f(arguments...)	函数调用
(experession,...)	绑定或元组显示
[expression,...]	列表显示
{key:datum,...}	字典显示
'expression,...'	字符串转换

其中我们还没有接触过的运算符将在后面的章节中介绍。

在表中列在同一行的运算符具有 相同优先级 。例如，+和-有相同的优先级。

计算顺序

默认地，运算符优先级表决定了哪个运算符在别的运算符之前计算。然而，如果你想要改变它们的计算顺序，你得使用圆括号。例如，你想要在一个表达式中让加法在乘法之前计算，那么你就得写成类似(2 + 3) * 4的样子。

结合规律

运算符通常由左向右结合，即具有相同优先级的运算符按照从左向右的顺序计算。例如，2 + 3 + 4被计算成(2 + 3) + 4。一些如赋值运算符那样的运算符是由右向左结合的，即a = b = c被处理为a = (b = c)。