py基础语法

输出：

print("wbshpnshp")

输入：
1.raw_input()

str = raw_input("请输入：")
print "你输入的内容是: ", str

2.input(), input 可以接收一个Python表达式作为输入，并将运算结果返回。

str = input("请输入：")
print "你输入的内容是: ", str

请输入：[x*5 for x in range(2,10,2)]
你输入的内容是: [10, 20, 30, 40]

标识符：

和c语言基本一样，区分大小写。
区别：
1._ foo但下划线代表不能直接访问的类属性。
2._ _ foo双下划线开头代表类的私有成员。
3._ foo _这样开头和借宿代表py特殊方法标识符，如 init() 代表类的构造函数。

变量赋值

xxx= ...

变量类型不需要申明会自动判断

多个变量同时命名：

a = b = c = 1
a, b, c = 1, 2, "john"

常用类型：

1.字符串:
左闭右开，0开始,*是重复操作，+是连续操作，str[X:Y]是截取操作

2.数字

3.元组：元组是另一个数据类型，类似于 List（列表）

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')

元组不允许更新，但是列表可以更新

4.字典：哈希表
定义字典：

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}

print tinydict.keys()      # 输出所有键
print tinydict.values()    # 输出所有值

类型转化方法：传送门
在这里插入图片描述

运算符号：
和c完全一样，**取幂，//向下取整

条件语句：

1.if else

if 判断条件：
    执行语句……
else：
    执行语句……

2.连续if else

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

3.py不支持switch语句，只能用elif

循环语句：

1.while

while 判断条件(condition)：
    执行语句(statements)……

py没有do…while

2.for

for iterating_var in sequence:
   statements(s)

break，continue，pass
pass 是空语句，是为了保持程序结构的完整性。

python2.x：

def function():
    # 空函数在Python2.x版本中pass是必须的
    pass
python3.x

def function():
    # 在Python3.x的时候pass可以写或不写
    pass

函数：
1.函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。

2.任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

3.函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

4.函数内容以冒号起始，并且缩进。

5.return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

函数定义：

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

函数调用：

functionname(....)

参数：

1.必备参数：所有参数都必须按顺序输入

2.关键字参数：可以不按照顺序输入：

#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print "Name: ", name
   print "Age ", age
   return
 
#调用printinfo函数
printinfo( age=50, name="miki" )

3.默认参数：
调用函数时，默认参数的值如果没有传入，则被认为是默认值。注意，在使用此格式定义函数时，指定有默认值的形式参数必须在所有没默认值参数的最后

4.不定长参数：

# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print "输出: "
   print arg1
   for var in vartuple:
      print var
   return
 
# 调用printinfo 函数
printinfo( 10 )
printinfo( 70, 60, 50 )

匿名函数：

python 使用 lambda 来创建匿名函数。lambda只是一个表达式，函数体比def简单很多。

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

例子:

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )

模块化:

导入：

# 导入模块
import support
 
# 现在可以调用模块里包含的函数了
support.print_func("Runoob")

指定导入：

from fib import fibonacci

全部导入：

from math import *

模块搜索路径：

当你导入一个模块，Python 解析器对模块位置的搜索顺序是：

1、当前目录
2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。

模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。

和模块导入的四个函数：
1.dir(模块名)输出所有模块里定义过的名字
2.globals() 如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
3.locals()如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
4.当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。该函数用来重载，重新导入一次

面向对象：

实例变量和类变量：

class person:
    i= 100;
    defer  __init__(self,name):
    self.username=name

上面的i是实例变量是所有类共享的，线面的username是类变量，是这个类独有的。

这里的init函数是构造函数，我们的self每个函数都必须有，这是构造函数，这个构造函数可以初始化。self是这个类实例本身，可以理解为this指针

好文传送，关于this和self的

私有成员变量

在Python里边，一个类的成员（成员变量、成员方法）是否为私有，完全由这个成员的名字决定。如果一个元成员的名字以两个下划线__开头，但不以两个下划线__结尾，则这个元素为私有的(private)；否则，则为公有的(public)。Pyhton里边并没有protected的概念。

为了方便表述，如果一个元素的名字以两个下划线__开头，但不以两个下划线__结尾，我们称这个元素的名字“符合私有定义”。

class Hugo:
    def __init__(self):
        self.__name = "hugo"

    def Say(self):
        # 在类内部使用私有成员变量__name
        print("my name is:", self.__name)

boy = Hugo()
boy.Say() # OK

# 此处抛出一个异常，提示__name不存在
print("name of boy:", boy.__name)

但是私有成员可以外部直接访问，但是不推荐：

class Hugo:
    def __init__(self):
        self.__name = "hugo"

    def Say(self):
        # 在类内部使用私有成员变量__name
        print("my name is:", self.__name)

boy = Hugo()
boy.Say() # OK

# 通过_Hugo__name可以在外部访问私有变量__name
print("name of boy:", boy._Hugo__name)

我们可以通过_Hugo__name可以在外部访问私有变量__name。然后，在实际开发中，如果没有特殊的需要，请不要这么做。我们将一个成员声明为私有，是有一定的原因的，其中一个最主要的原因，就是不希望使用者直接访问它。虽然我们还是可以这么做，但请务必遵守这个约定，以免出现不必要的问题。

继承：

py中继承类似于js？？？？？？用super？？？

例子：

class Animal(object):  #  python3中所有类都可以继承于object基类
   def __init__(self, name, age):
       self.name = name
       self.age = age

   def call(self):
       print(self.name, '会叫')

######
# 现在我们需要定义一个Cat 猫类继承于Animal，猫类比动物类多一个sex属性。 
######
class Cat(Animal):
   def __init__(self,name,age,sex):
       super(Cat, self).__init__(name,age)  # 不要忘记从Animal类引入属性
       self.sex=sex

if __name__ == '__main__':  # 单模块被引用时下面代码不会受影响，用于调试
   c = Cat('喵喵', 2, '男')  #  Cat继承了父类Animal的属性
   c.call()  # 输出 喵喵 会叫 ，Cat继承了父类Animal的方法

注意：

1.一定要用 super(Cat, self).init(name,age) 去初始化父类，否则，继承自 Animal的 Cat子类将没有 name和age两个属性。
2.函数super(Cat, self)将返回当前类继承的父类，即 Animal，然后调用__init__()方法，注意self参数已在super()中传入，在__init__()中将隐式传递，不能再写出self。
3. python3.0可以用super().xxx代替super(class, self).xxx 作业可以注释区分一下

重写父类的方法：

class Cat(Animal):
   def __init__(self, name, age, sex):
       super(Cat, self).__init__(name,age)
       self.sex = sex

   def call(self):
       print(self.name,'会“喵喵”叫')