python学习之入门基础

hello wold

print ‘hello world!’

print是一个常用函数，其功能就是输出括号中的字符串或者其他类型的数值

python脚本

新建sum.py

#！/usr/bin/env python
a=1
b=1
print a+b

chmod +x sum.py
./sum.py

结果输出为2

数据类型

a = 3
print (type(a))

• int a=3
• float a=3.1
• 真值 a=True
• 字符串

序列 sequence

• 序列是一组有顺序的元素的集合
• 包含一个或多个元素，也可以没有
• 主要分为两类：tuple和list（主要区别在于tuple的各个元素不可改变，list元素可改变
• 字符串一种特殊的元祖

s1 = (1,'python', 2)
s2 = [5, 4, 2]
s3 = [1,[2,3,4]]
print s1,type(s1)
print s2,type(s2)
print s1[0]
print s3[1]
print s2[2:0:-1]
s = "asda"
print s[0:3]

(1, 'python', 2) <type 'tuple'>
[5, 4, 2] <type 'list'>
1
[2, 3, 4]
[2, 4]
asd

引用方式

• 下标引用
• 范围引用：[下限:上限：步长]，但是上限本身不引用，print s[0:3:1], s[3]不会打印

字典dict-map

dict使用键值存储(key-value),具有极快的查找速度

kv = {'name':'jack','id':2}
print kv
print kv['name']
# dict可修改
kv['name'] = 'rose'
print kv['name']
# 可通过in判断key是否在dict中
print 'name' in kv
# dict还可通过get方法获取对应的value
print kv.get('name')
print kv.get('id')
# pop删除，返回删除的值，并删除
print kv.pop('id')
print kv

{'name': 'jack', 'id': 2}
jack
rose
True
rose
2
2
{'name': 'rose'}

dict和list比较

• 查找和插入的速度极快，dict不会随着key的增加而变慢，list查找和插入的时间随着元素的增加而增加；
• dict需要占用大量的内存，内存浪费多，list占用空间少，内存浪费少
• dict用空间换时间
• dict的key是不可变的且不重复，因此key必须是不可变的值，比如字符串和数字

set

set和dict类似，但是只是key的集合，不存在value，set中没有重复的key,它的key和dict里的key一模一样

s = set([1,1,1,3,2,2,3])
print s
# set添加
s.add(5)
print s
# set删除
s.remove(1)
print s
# set可做交集和并集    
s1 = set([1,2,3])
s2 = set([2,3,4,5])
print (s1&s2)
print (s1|s2)
# tuple不变，可作为key
q = (1,2)
s.add(q)
print s

set([1, 2, 3])
set([1, 2, 3, 5])
set([2, 3, 5])
set([2, 3])
set([1, 2, 3, 4, 5])
set([(1, 2), 2, 3, 5])

运算

• +, -, , /, *, %
• ==, !=, >, >=, <, <=, in
• and, or, not

缩进

在c、c++和java中，一块代码都是利用{}完成，而python最具特色的就是利用缩进表明成块的代码，四个空格表示隶属关系

val = input()
if val == 1:
    print ('c++')
elif val == 2:
    print ('java')    
else:
    print ('python')

循环

• for

for i in range(3):
    print i

• while

i = 0
while i<3:
    print i
    i=i+1

• 结果

1
2
3

函数

函数的最主要作用就是减少重复，方便用户调用，将一些操作放入一个函数内进行封装

• 求和函数示例

def sum(a,b):  #def关键字通知python定义了一个函数
    return a+b 

if __name__ == "__main__":
    a=input()
    b=input()
    sum = sum(a,b)
    print(sum)

• 参数传递之值传递和指针传递

def valueChange(a):    #值传递
    a=a+1
    return a

def pointerChange(b):  #指针传递
    b[0] = b[0]+1
    return b

if __name__ == "__main__":

    a =1
    print(valueChange(a))
    print(a)

    b = [1,2]
    print(pointerChange(b))
    print(b)

2
1
[2, 2]
[2, 2]

上述代码分别为值传递和指针传递代码的结果，但是可看到结果完全不同，为什么呢？解释一下

值传递：基本类型变量传给函数后，函数会在内存中复制一个新的变量，之后的操作都是对这个新的变量进行，从而不影响旧变量值的改变

指针传递：列表传递给函数的是一个指针，指针指向序列在内存中的位置，在函数中对表的操作，也是在原有内存中进行，改变原有值，从而影响原有变量

面向对象

面向对象主要为提高程序的重复使用性，以减少代码冗余。Python主要使用类(class)和对象(object)完成面向对象的编程。

何为对象？

面向对象编程是一种程序设计思想，一个对象包含了数据和操作数据的函数，而对象是一种抽象的概念，自然界中的所有实物都可抽象成对象，其包含了类和实例，类就是属性相近的一系列对象，实例就是对类进行实例化，生成对象，属性也很具体。映射到生活中，数据就是一个对象的属性值，有私有数据有公用数据，函数就是对象操作数据的一种方式。

类与实例

class Student(object)
    pass

class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，通常，如果没有合适的继承类，就使用object类，object是所有类的父类。

当创建好类后，便可创建一个实例对象

newboby = Student()
print newboby
<__main__.Student instance at 0x0000000002E96BC8>

从上述中可看出，当对象创建，会在内存中分配一块空间，0x0000000002E96BC8即为对象对应的内存空间地址

构造函数__init__

class Student():
    def __init__(self,name=None,id=None):
        self.name = name
        self.id = id

注意到init方法的第一个参数永远是self，表示创建的实例本身，因此，在init方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身

数据封装

class Student():
    def __init__(self,name=None,id=None):
        self.name = name
        self.id = id

    def printname(self):
        print self.name

数据封装主要是将数据和逻辑封装到类内部，外部访问时并不知道内部实现细节

访问权限

私有变量，实例的变量名如果以’_’开头，此变量就为一个私有变量，只有内部自身可以调用，外部不能访问

需要注意的是，在Python中，变量名类似xxx的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用name、score这样的变量名。

‘__’双下划线，主要避免子类覆盖其内容，子类重写也不会改变内部逻辑和返回

继承和多态

就不总结了，看这里：
https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431865288798deef438d865e4c2985acff7e9fad15e3000

获取对象信息

• type() 对象类型
• isinstance() 判断class的类型
• dir() 获取对象所有属性和方法，返回一个list
• getattr() 获取属性值
• setattr() 设置属性值
• hasattr() 判断是否有属性

实例属性和类属性

class Student(object):
    name = 'Student'

    def __init__(self):
        self.name = 'xiaoming'

    def printname(self):
        print self.name

if __name__ == "__main__":
    s = Student()
    print s.name
    print Student.name

xiaoming
Student

上述代码中发现实例属性的绑定主要是通过实例变量或者self变量绑定，而类的属性主要是类自身属性值，上述代码中name就为属性

高级特性

• slots：限定属性名称

__slots__=('name','age') # 只有name和age属性可绑定，其余属性不行

• @property

负责将一个方法变成属性调用，但是每调用一次就会计算一次，浪费cpu

• @lazy

@property的改进，调用多次，只计算一次

• __len__()方法：让class作用于len()函数
• __str__()方法

class Student(object):
    def __init__(self,name):
        self.name = name
    def __str__(self):
        return '(name:{})'.format(self.name)
if __name__ == "__main__":
    print Student('xiao')

(name:xiao)

__str__ 就是制定类的打印

• __iter__ 类进行for循环