1.Python的内置数据结构

（1）列表 

     创建：通过一对花括号创建，元素可为任意类型，例如：list={"xiaozhang",1001},也可以通过内建函数list创建

     访问：通过下表访问，例如 print list[0]  结果为:xiaozhang，列表中的元素也可以为列表，叫做二维列表，访问方式和二维数组相同

      还可以通过切片的方式访问，如 list[0:1]

     修改：方式一：list[0]=‘1‘;  这样就把xiaozhang换成1了  方式二：可一次性修改多个list[0:1]=[1,2]

      删除：1）通过remove()函数，参数为要删除的值

                 2）通过del(）函数，删除列表中指定索引的值。

（2）元组，通过内建函数tuple()实现或用一对（）创建，元组是不可变序列类型，所以只有访问，没有删除和增加，访问方法同列表相似，也是通过切片的方式。

（3）字典  是一个键值对，通过key来访问value，key必须是可哈希的类型。

      创建：1）普通方式创建：student={1001:‘xiaozhang‘,1002:‘xiaowang‘}

                2）dict()函数：studeng=dict([1001:‘xiaozhang‘,1002:‘xiaowang‘]),函数参数是键值对形式的列表或者元组。

      访问：1）指定键的方式：

print "通过指定键的方式(2.2前)"
for key in student.keys():
    print "student[%s]=" %key,student[key];
print "通过指定方式（2.2后）"
for key in student:
    print "student[%s]=" % key, student[key];

                 2）通过items（）函数

print ‘内建函数items‘
for (key,values) in student.items():
    print ‘student[%s]=‘ % key,values

                3）通过函数iteritems(),用法同2)中函数，只是本函数返回的是迭代器，（2）返回的是元组

      跟新字典：

       1）添加元素：可通过赋值语句实现：dictionary[key]=value,例如：student[1001]=‘xiaoli‘。如果key在字典中不存在，那么直接讲元素添加到字典中，若存在就更新对应key所关联的value。

       2）使用dictionary.setdefault(key,[value])函数添加元素，key为字典的键，value可有可无，默认为none，如果要添加的参数key在字典中已经存在，那么该函数将返回原有的值。例：student.setdefault(1004,‘xiaoliu’)，此时1004对应的value为xiaoliu ，再次使用student.setdefault(1004,‘xiaohe’)，此时1004的value并没有变为xiaohe，仍然为xiaoliu。

    删除元素：

       1）通过del()函数删除字典中的元素，语法格式为：del(dictionary_name[key])，根据字典的key值删除元素，被删除的元素一定要存在，否则抛出KeyError异常。

       2)通过pop()函数删除字典中的元素，语法格式为：dictionary_name.pop(key,[defaultvalue]),key对应的元素存在，返回value并删除此键值对，不存在就返回defaultvalue的值，且不会抛出异常。

 (4)集合，集合是一种无序不重复的元素集，元素要为可哈希的对象，类型分为可变集合set和不可变集合fozenset，常用于成员关系测试和重复条目消除。

     创建集合：1）创建可变集合通过使用花括号，里面的每一个元素用逗号分割或通过set()来实现。创建不可变集合只能通过frozenset()来实现。

     例如:可变集合：student1_set={‘xiaoming‘,‘xiaohua‘}   student_set=set([‘xiaoli‘,‘xiaoming‘])  

              不可变集合：student1_set=frozenset([‘xiaoming‘,‘xiaohua‘])

     添加元素：通过set.add()给集合添加一个元素，若想一次性添加多个元素可通过set.update()实现

     删除元素：1）通过remove(obj)或者discard(obj)删除集合中的元素，obj不是集合中的元素，remove将会抛出KeyError异常，discard不会抛出。

                       2）通过pop()删除，删除集合中的第一个元素并返回

                       3）clear()清除集合中的所有元素。

2.Python中的函数。

   1）定义格式  

def  函数名([参数列表]):

     ‘文档字符串‘

    函数体

其中有空函数的概念，定义形式为

def  函数名([参数列表]):

     ‘文档字符串‘

    pass

   2）参数传递：python中的参数传递都是采用的引用方式，调用时实参和形参两者指的相同的对象。但又分为可变对象（列表字典等）和不可变对象（整形，浮点，字符串和元组等），当为可变对象时函数中改变形参实参也会对应修改，不可变对象在函数中的修改不影响实参的值。

  3)可变长度参数： def 函数名([位置参数，默认参数参数]，*vargs_turple).vargs_turple为非关键字可变长度参数，以元组的方式保存了匹配前面的位置参数和默认参数后剩下的所有参数。一般可用for循环迭代取值。  def 函数名([位置参数，默认参数参数]，[*vargs_turple],**vars_dist).**vars_dist为关键字可变长度参数。它以字典的方式存储了匹配完前面的参数剩下的参数。

# coding:utf-8
def keywordVarargs(posarg, defarg=‘defVal‘, * varargs, ** kwvargs):
   print ‘位置参数ppsarg：‘,posarg
   print ‘默认参数defarg:‘,defarg
   for eachvar in varargs:
      print ‘非关键字可变长度参数：‘,eachvar
   for key in kwvargs:
      print ‘关键字可变长度参数‘+key+‘：‘,kwvargs[key]
print ‘不指定关键字可变长度参数：‘
keywordVarargs(123, ‘abc‘, 456, ‘wer‘)
print ‘指定关键字可变长度参数：‘
keywordVarargs(123, ‘abc‘, 456, ‘wer‘, kw1=1, kw2=‘333‘)

输出结果：

不指定关键字可变长度参数：
位置参数ppsarg： 123
默认参数defarg: abc
非关键字可变长度参数： 456
非关键字可变长度参数： wer
指定关键字可变长度参数：
位置参数ppsarg： 123
默认参数defarg: abc
非关键字可变长度参数： 456
非关键字可变长度参数： wer
关键字可变长度参数kw1： 1
关键字可变长度参数kw2： 333
3.面向对象编程

 Python中也是通过关键字class来定义一个类，用法与Java基本一致。但Python也有其特别的语法规则。

（1）Python中没有private和public关键字，所以想要申明私有变量或者私有方法，是通过特殊符合表示的，以两个下划线开头，则说明是私有属性。例如私有属性__manufactuePrice=20.在类外用 对象.__manufactuePrice是访问不到的。其实并不是真的访问不到，只是编译器自动把这种属性名变为 _Car__manufactuePrice,通过

对象._Car__manufactuePrice仍然可以访问到。

（2）Python中的构造函数为__init__(self)函数。这个方法只能定义一遍，不允许重载，当定义多个，后面的会覆盖前面的。想要实现构造函数的重载可使用默认参数的形式。

class Car(object):
   """docstring for Car"""
   # def __init__(self):
   #  pass
   def __init__(self, name=None,model=None,year=None):
      self.__name = name;
      self.__model=model;
      self.__year=year;
      self.__oldmeter=0;
   def setName(self, name):
      self.__name=name;
   def setModel(self, model):
      self.__model=model;
   def setYear(self, year):
      self.__year=year;
   def setOldmeter(self, oldmeter):
      self.__oldmeter=oldmeter;
   def get_descriptive_name(self):
      """"return all descriptive_name"""
      long_name=str(self.__year)+‘ ‘+str(self.__name)+‘ ‘+str(self.__model);
      return long_name;
   def read_oldmeter(self):
      print "The car has "+str(self.__oldmeter)+‘ miles on it.‘;
   def update_oldmeter(self,mileage):
      self.__oldmeter=mileage;
   def increment_oldmeter(self,miles):
      self.__oldmeter+=miles;
   def fillGasTank(self,gas):
      print "The car has add "+str(gas)+‘ gas.‘;

 主函数:

from ClassTest import Car, ElectricCar
my_new_car = Car()
my_new_car.setName(‘aodi‘)
my_new_car.setModel(‘A6‘)
my_new_car.setOldmeter(1000)
my_new_car.setYear(2016)
print ‘Car name:‘
print(my_new_car.get_descriptive_name());
my_new_car.read_oldmeter();
my_new_car.update_oldmeter(23);
my_new_car.read_oldmeter();
my_new_car.increment_oldmeter(100);
my_new_car.read_oldmeter();
my_new_car.fillGasTank(220);
print my_new_car._Car__name;
my_new_car2 = Car(‘frali‘,‘23‘,2016)
print ‘Car name:‘
print(my_new_car2.get_descriptive_name());
my_new_car2.read_oldmeter();
my_new_car2.update_oldmeter(23);
my_new_car2.read_oldmeter();
my_new_car2.increment_oldmeter(100);
my_new_car2.read_oldmeter();
my_new_car2.fillGasTank(220);
print my_new_car2._Car__name;

输出结果：

Car name:
2016 aodi A6
The car has 1000 miles on it.
The car has 23 miles on it.
The car has 123 miles on it.
The car has add 220 gas.
aodi
Car name:
2016 frali 23
The car has 0 miles on it.
The car has 23 miles on it.
The car has 123 miles on it.
The car has add 220 gas.
frali

（3）类方法和静态方法：可通过@classmethod和@staticmethod方法或者对应的内建函数将一个普通的方法转换为类方法或者静态方法。

python学习笔记