python基础学习笔记1

hello word！

脚本helloword.py 

#!/usr/bin/env python
print('Hello World!')

两种执行方式：

1. $python helloword.py

   Hello World!

 

2. $./ helloword.py

   Hello World!

 

注意：脚本首行就是给执行方式2，指定解释器；就和写shell 脚本时首行指定 bash一样；

          如果用第一种方式，执行。首行不写也可以正确执行噢！通常情况还是要写上去的；

 

基本数据类型

变量不需要声明

>>>a = 10
>>>print a
>>>print type(a)

输出会如下：

10

<type 'int'>

这里要注意的是内置函数 type()查询变量的类型；

当然变量不需要声明，所以当你想在a中放入其他类型数据也是可以的噢；

>>>a = 1.3
>>>print a,type(a)

输入如下：

1.3 <type 'float'>

 

序列 sequence

sequence是一组有顺序的元素的集合；

序列有两种：tuple(定值表；也有翻译为元祖) 和list（表）

>>>s1 = (2, 1.3, 'love', 5.6, 9, 12, False)         # s1是一个tuple

>>>s2 = [True, 5, 'smile']                          # s2是一个list

>>>print s1,type(s1)

>>>print s2,type(s2)

输出：

(2, 1.3, 'love', 5.6, 9, 12, False)  <type 'tuple'>   

[True, 5, 'smile']  <type 'list'>   

 

注意：tuple 与 list 的区别是tuple 在给定之后不可改；而list可更改

         判定是tuple，或者 list 是通过（）和[]来判定的噢！

 

一个序列作为另一个序列的元素

>>>s3 = [1,[3,4,5]]

空序列

>>>s4 = []

 

序列元素的引用更改：

序列的引用通过s[<int>]实现， int为下标s为序列符号

例如上面：取s1 的第二个元素 s2的第三个元素

>>>print s1[1]
1.3
>>>print s2[2]
smile
>>>print s3[1][2]                   #有点二维数组的味道
5

注意：下标也是从0开始的噢；

 

 

其他引用方式：

范围引用： 基本样式[下限:上限:步长]

重点：不包括上限元素本身噢，如果有上限；

 

>>>print s1[:5]        # 从开始到下标4 （下标5的元素 不包括在内）
>>>print s1[2:]        # 从下标2到最后
>>>print s1[0:5:2]     # 从下标0到下标4 (下标5不包括在内)，每隔2取一个元素 （下标为0，2，4的元素）
>>>print s1[2:0:-1]    # 从下标2到下标1

尾部元素引用

>>>print s1[-1]             # 序列最后一个元素
>>>print s1[-3]             # 序列倒数第三个元素

同样，如果s1[0:-1], 那么最后一个元素不会被引用 （再一次，不包括上限元素本身）

 

字符串是一个tuple；

字符串是一种特殊的元素，因此可以执行元组的相关操作

>>>str = 'abcdef'
>>>print str[2:4]

运算

数学运算

>>>print 1+9        # 加法

>>>print 1.3-4      # 减法

>>>print 3*5        # 乘法

>>>print 4.5/1.5    # 除法

>>>print 3**2       # 乘方     

>>>print 10%3       # 求余数

 

判断返回True/False

>>>print 5 in [1,3,5]       # 5是list [1,3,5]的一个元素

==, !=, >, >=, <, <=, in

 

逻辑运算

and, or, not 与或非

 

缩进和选择

Python最具特色的是用缩进来标明成块的代码；

用缩进空格来表示隶属关系；

if语句之后的冒号

以四个空格的缩进来表示隶属关系, Python中不能随意缩进

if  <条件1>:

    statement

elif <条件2>:

    statement

elif <条件3>：

    statement

else:

    statement

 

循环

for循环

基本构造是

 

for 元素 in 序列: 
    statement

举例：

for a in [3,4.4,'life']:

    print a

打印这个list中每一个元素；

 

range()，函数来建list表；

idx = range(5)

print idx

输出：

[0, 1, 2, 3, 4]

这个函数的功能是新建一个表。这个表的元素都是整数，从0开始，下一个元素比前一个大1， 直到函数中所写的上限 （不包括该上限本身）

举例：

for a in range(10):
    print a**2

 

while循环

while 条件:
    statement

while会不停地循环执行隶属于它的语句，直到条件为假(False)

 

举例

while i < 10:
    print i
    i = i + 1

 

中断循环

continue   # 在循环的某一次执行中，如果遇到continue, 那么跳过这一次执行，进行下一次的操作

break      # 停止执行整个循环

举例

for i in range(10):
    if i == 2: 
        continue

    print i

输出除2以外的0-9；

 

for i in range(10):

    if i == 6:       

        break

    print i

输出0-5,6的时候已经跳出所以不输出；

 

函数

函数最重要的目的是方便我们重复使用相同的一段程序。

函数的定义

def square_sum(a,b):
    c = a**2 + b**2

    return c

这个函数的功能是求两个数的平方和。

首先，def，这个关键字通知python：我在定义一个函数。square_sum是函数名。

括号中的a, b是函数的参数，是对函数的输入。参数可以有多个，也可以完全没有（但括号要保留）

c = a**2 + b**2        # 这一句是函数内部进行的运算

return c               # 返回c的值，也就是输出的功能。Python的函数允许不返回值，也就是不用return。

return可以返回多个值，以逗号分隔。相当于返回一个tuple(定值表)。

return a,b,c          # 相当于 return (a,b,c)

函数参数的传递

变量传递是值传递

表传递是  地址传递

 

面向对象的基本概念

Python使用类(class)和对象(object)，进行面向对象（object-oriented programming，简称OOP）的编程

 

相近对象归为类

定义鸟类：

class Bird(object):
    have_feather = True
    way_of_reproduction  = 'egg'

 

创建对象

summer = Bird()
print summer.way_of_reproduction

可怜的summer，你就是个有毛产的蛋货，好不精致。

 

动作

class Bird(object):      #object说明Bird类没有父类                             
　　 have_feather = True
    way_of_reproduction = 'egg'
    def move(self, dx, dy):
        position = [0,0]
        position[0] = position[0] + dx
        position[1] = position[1] + dy
        return position

summer = Bird()
print 'after move:',summer.move(5,8)

注意： 它的参数中有一个self，它是为了方便我们引用对象自身。方法的第一个参数必须是self，无论是否用到。

　　　 dx, dy表示在x、y两个方向移动的距离。move方法会最终返回运算过的position。

         在最后调用move方法的时候，我们只传递了dx和dy两个参数，不需要传递self参数（因为self只是为了内部使用）

 

我的summer可以跑了。

 

子类

类别本身还可以进一步细分成子类比如说，鸟类可以进一步分成鸡，大雁，黄鹂。

在OOP中，我们通过继承(inheritance)来表达上述概念。

 

class Chicken(Bird):
    way_of_move = 'walk'
    possible_in_KFC = True

class Oriole(Bird):
    way_of_move = 'fly'
    possible_in_KFC = False

summer = Chicken()
print summer.have_feather
print summer.move(5,8)

新定义的鸡（Chicken）类的，增加了两个属性：移动方式（way_of_move），可能在KFC找到（possible_in_KFC）

在类定义时，括号里为了Bird。这说明，Chicken是属于鸟类（Bird）的一个子类，即Chicken继承自Bird。自然而然，Bird就是Chicken的父类。Chicken将享有Bird的所有属性。

尽管我只声明了summer是鸡类，它通过继承享有了父类的属性（无论是变量属性have_feather还是方法属性move）

 

注意：若定义类是括号中为object则该类没有父类；

 

self

定义类的方法是，必须有self，这个参数表示某一具体的对象；可以通过self,调用类的属性；对象的性质，也是通过self来改变的。

class Human(object):
    def __init__(self, input_gender):
        self.gender = input_gender
    def printGender(self):
        print self.gender
li_lei = Human('male') # 这里，'male'作为参数传递给__init__()方法的input_gender变量。
print li_lei.gender
li_lei.printGender()

__init__()方法

是一个特殊的方法，python有一些特殊的方法，python会特殊的对待他们。特殊方法的特点是前后有两个下划线。

例子：

class happyBird(Bird):
    def __init__(self,more_words):
        print 'We are happy birds.',more_words
summer = happyBird('Happy,Happy!')

屏幕上打印：

We are happy birds.Happy,Happy!

 

__init__()方法，是初始化的过程；python在创建对象时，自动调用这个方法，这个过程叫做初始化的过程。

 

everything is object 

 

dir()

查询一个类或者对象所有属性

help（）

查询说明文档

 

list是一个类，是python已经定义好的一个类，当我们新建一个表时，如：

>>>nl = [1,2,5,3,5]

实际上，n1是类list的一个对象

那么list既然是一个类，那我们n1对象就可以调用它的方法：

>>>print nl.count(5)        # 计数，看总共有多少个5
>>>print nl.index(3)        # 查询 nl 的第一个3的下标
>>>nl.append(6)             # 在 nl 的最后增添一个新元素6
>>>nl.sort()                # 对nl的元素排序
>>>print nl.pop()           # 从nl中去除最后一个元素，并将该元素返回
>>>nl.remove(2)             # 从nl中去除第一个2
>>>nl.insert(0,9)           # 在下标为0的位置插入9

 

运算符是特殊方法

使用dir(list)的时候，能看到一个属性，是__add__()。从形式上看是特殊方法（下划线，下划线）。

它特殊在哪呢？这个方法定义了"+"运算符对于list对象的意义，两个list的对象相加时，会进行的操作。

>>>print [1,2,3] + [5,6,9]

运算符，比如+, -, >, <, 以及下标引用[start:end]等等，从根本上都是定义在类内部的方法。

尝试一下

>>>print [1,2,3] - [3,4]

会有错误信息，说明该运算符“-”没有定义。现在我们继承list类，添加对"-"的定义

class superList(list):
    def __sub__(self, b):
        a = self[:]     # 这里，self是supeList的对象。由于superList继承于list，它可以利用和list[:]相同的引用方法来表示整个对象。
        b = b[:]       
        while len(b) > 0:
            element_b = b.pop()
            if element_b in a:
                a.remove(element_b)
        return a

print superList([1,2,3]) - superList([3,4])

内置函数len()用来返回list所包含的元素的总数。内置函数__sub__()定义了“-”的操作：从第一个表中去掉第二个表中出现的元素。如果__sub__()已经在父类中定义，你又在子类中定义了，那么子类的对象会参考子类的定义，而不会载入父类的定义。任何其他的属性也是这样。

 

总结

• 内置函数type(),查询变量类型
• 序列sequence
  • 区别tuple,不可更改，list可更改
  • tuple用小括号，list用中括号
  • tuple: 定值表(元组)
    • s1=(2,1.3,'love',False,12)
  • list：表
    • s1=[Ture,5,'simple']
      • s1[1]值为5
    • s3=[1,[2,3,4]]
      • s3[1][0]值为2
  • 引用方式
    • [下限:上限:步长]
      • 注意如果有上限，是不含上限本身的。
      • s1[:5] # 从开始到下标4 （下标5的元素 不包括在内）
      • s1[2:] # 从下标2到最后
      • s1[0:5:2]     # 从下标0到下标4 (下标5不包括在内)，每隔2取一个元素 （下标为0，2，4的元素）
      • s1[2:0:-1] # 从下标2到下标1
    • 尾部元素引用
      • s1[-1] # 序列最后一个元素
      • s1[-3] # 序列倒数第三个元素
  • 字符串是一个tuple，因此也使用上面引用方式
• 判断返回
  • print 5 in [1,3,5]，返回TRUE
• 语法
  • 使用缩进表示隶属关系
  • if <condition>:      注意冒号
  • 循环
    • for 元素 in 序列:    注意冒号
    • range()函数来建立list表
    • while
  • 函数
    • def squeare_sum(a,b):
• 面向对象
  • 定义类->创建对象->对象引用类属性
  • 类中的方法第一个参数必须是self,无论是否用到。方便自身引用。
  • object作为没有父类的 类
  • __init__()方法，是初始化的过程；python在创建对象时，自动调用这个方法，这个过程叫做初始化的过程。
• dir():查看对象或者类的所有属性；
• help():查看类或对象的帮助信息；
• list类的方法
  • >>>print nl.count(5) # 计数，看总共有多少个5
  • >>>print nl.index(3) # 查询 nl 的第一个3的下标
  • >>>nl.append(6) # 在 nl 的最后增添一个新元素6
  • >>>nl.sort() # 对nl的元素排序
  • >>>print nl.pop() # 从nl中去除最后一个元素，并将该元素返回
  • >>>nl.remove(2) # 从nl中去除第一个2
  • >>>nl.insert(0,9) # 在下标为0的位置插入9
• 如果属性或方法已经在父类中定义，你又在子类中定义了，那么子类的对象会参考子类的定义，而不会载入父类的定义。