Python基础语法以及在windows下如何导入模块

一.  什么是python

是一种使你在编程时能够保持自己的风格的程序设计语言，你不用费什么劲就可以实现想要的功能，并且编写的程序清晰易懂。一种解释型的 、面向对象的、带有动态语义的高级程序设计语言。

二.  Python特性

1.      脚本语言

2.      高阶动态编程语言

解释性和编译性:运行不需要编译成二进制代码，可以直接运行源代码，但是需要解释器。

3.      可扩展性及可嵌入性:可以在其中嵌入C或者C++

4.      面向对象

5.      免费、开源

6.      可移植性

7.      丰富的库

三.  Python文件类型

1.      源代码：以py为扩展名，不需要编译

2.      字节代码

a)        Python源文件经编译后生成的扩展名为’pyc’的文件

b)        编译方法:import py_compile  py_compile.compile(“hello.py”)

3.      优化代码：经过优化后的代码扩展名为.pyo，python –O –m py_compile hello.py

SyntaxError: invalid syntax:无效语法

四.  python的赋值是以数据为主。

>>>a = 123

>>>b= 123

>>>id(a)

19964200

>>>id(b)

19964200

五.  python运算符和表达式

3**3:3求三的3次方

#!C:\Python27

a =int(raw_input("please input n1:"))

b =int(raw_input("please input n2:"))

print a+b

print a-b

print a*b

print a/b

六.  Python的数据类型

1.      数字:

>>>n = 1

>>>type(n)

>>>a = 1111111111111111111111111111111111111111

>>>type(a)

>>>a = 12e+7

>>>a

120000000.0

>>>a = 12e-7

>>>a

1.2e-06

>>>type(a)

>>>c = 13j

>>>c

13j

>>>type(c)

2.      字符串:

>>>a = "123"

>>>type(a)

>>>str = 'hello'

>>>type(str)

>>>str = """hello"""

>>>type(str)

>>>a = 'abcde'

>>>a[0]

'a'

>>> a[1]

>>>a[0]+a[1]

'ab'

>>>a[1:4]

'bcd'

>>>a[:4]

'abcd'

//步长为2

>>>a[::2]

'ace

>>>a[-1]

'e'

>>>a[1:-1]

'bcd'

>>>a[-2:-4:-1]

'dc'

3.      列表(序列)

>>>list.append(2)

>>>list[3]

2

>>> list[0] = 555

>>>list.remove(list[4])

>>> list[4]

>>>del(list[0])

>>>list

[2, 3, 2]

4.      元组:

a)        和列表十分相似，只不过元组和字符串一样是不可变的，即你不能修改元组

b)        元组通过圆括号中逗号分割的项目定义

c)        元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候，即被使用的元组值不改变。

>>> t =("wy","pengyulaopo",18)

>>>t[0]

'wy'

>>>t[0:2]

('wy', 'pengyulaopo')

 

>>> t =(1,)

>>>type(t)

5.      字典{}:

>>> ss = {'name':'wangying','age':18}

>>>ss['name']

'wangying'

>>>ss['age']

18

a)        创建字典

                                    i.             {}

                                  ii.             使用工厂方法dict()

                                 iii.             内建方法：fromkeys()，字典中的元素具有想通值，默认为none

1.        例:ddict={}.fromkeys((‘x’,’y’),-1)

b)        更新和删除

                                    i.             直接用键值访问更新；内建的update()方法可以将整个字典的内容拷贝到另一个字典中

>>> ss['tel']='15606135991'

                                  ii.             del dict1[‘a’] 删除

1.        dict1.pop(‘a):删除并且返回键为a的元素

2.        dict1.clear:删除字典所有元素

3.        del dict1:删除整个字典

序列的基本操作

1.      len():求序列长度

2.      +:连接两个序列

3.      *:重复序列元素

>>> ss*5

'wywywywywy'

4.      in:判断元素是否在序列中

5.      max():

6.      min():

7.      cmp(t1,t2):比较两个序列值是否相等

七.  流程控制

1.      分支结构

a)      逻辑值包含两个值:

True:表示非空值，所有非零数

False:表示0，None，空的量等

         #!C:\Python27

def fun():

                       return0

if fun():

                        print"OK"

else:

                print "NO"

 

#!C:\Python27

deffun():

    return 0

x= int(raw_input("please input a num:"))

ifx>=90:

    print "OK"

elifx>=80:

    print "aa"

else:

    print("bad")

2.      逻辑运算符

a)        and:

b)        or:

c)        not:

3.      for循环

a)        在python for循环遍历序列，如一个列表或一个字符。

b)        for循环语法:

for iterating_varin sequence statements(s)

注:如果一个序列包含一个表达式列表，它是第一个执行。    

c)        迭代序列指数

                                    i.             遍历每一个项目的另一种方法是由序列本身的偏移指数(索引)

d)        range

                                    i.             循环结构是用于迭代多个项的for语句，迭代形式可以循环序列的所有成员

                                  ii.             range(I,j,[步进值])

如果创建的对象为整数，则可以使用，初始、结束和步进

4.      遍历

a)        序列取值

#! C:\Python27

 

for x in "hello":

    print x

s = "hello"

for x in range(len(s)):

    print s[x]

b)        字典遍历

#! C:\Python27

 

s = {1:11,2:22,3:33}

print s.items()

 

s = {1:11,2:22,3:33}

for k,v in s.items():

print k

    print v

5.      循环控制

#! C:\Python27

 

s = {1:11,2:22,3:33}

 

for k,v in s.items():

   print k

   print v

else:

    print "ending"

else会在执行完for之后再执行。

#! C:\Python27

import time

 

s = {1:11,2:22,3:33,4:44,5:55,6:66}

 

for k,v in s.items():

   print k

   print v

   time.sleep(1)

   if k==2:

       pass //占位符

   if k==5:

       exit() //跳出整个执行

   if k==5:

       continue //跳到下一个循环

   print "nihao"

else:

    print "ending"

按住ctrl+c就可以强制结束，但是没有执行完

6.      while

while True:

   print "hello"

   x = raw_input("input:")

   if x=="q":    //基本每个判断后面都有冒号

        break

x=""

while x!="q":

   print "hello"

   x = raw_input("input:")

   if not x:

       break

else:

    print "ending..."

八.  函数

a)        函数就是完成特定功能的一个语句组，可以作为一个单位使用

b)        在不同地方可以多次执行

c)        自定义函数

d)        预定义的python函数

定义:def 函数名():函数体

1.      形式参数和实际参数

a)        在定义函数时函数名后面括号中的变量成为”形参”。

b)        调用函数时传入的参数叫实参。

#! C:\Python27

#coding:gbk

 

def fun():

    if True:

        print "你好"

def fun(a="我爱王莹")://提前赋值就是默认参数

    if True:

        print a

        print "你好"

2.      全局变量和局部变量

a = 100

 

def fun():

   global b

   b = 200

   print a

fun()

print b

内部成员变量只有声明为global才是全局，且必须执行fun函数之后b才能被实例化。

3.      函数返回值

在函数中只要遇到return就会终止这个函数。

4.      冗余参数处理

a)        多类型传值，比如有元组和字典

t = ('name','yannis')

def f(x,y):

   print "%s : %s" % (x,y)

f(*t)

本来是必须传入两个参数，但是在元组前面加一个*号就可以默认只传入一个元组。print后面的两个s是表示占位，表示还不知道什么值，先占位为String

def s(name="name",age=0):

   print "name : %s" % name

   print "age : %s" % age

s("wangying",20)

 

def s(name="name",age=0):

   print "name : %s" % name

   print "age : %s" % age

m = ('wy',18)

s(*m)

字典:

def s(name="name",age=0):

   print "name : %s" % name

   print "age : %s" % age

d = {'age':20,'name':'wangying'}

s(**d)

b)        处理多余实参

元组

def f(x,*args):

   print x

   print args

f(1,3,6,7)

字典:

def f(x,*args,**kargs):

   print x

   print args

   print kargs

f(1,2,3,4,5,6,7,y=1,name='wangyingwoaini')

lambda

1.      匿名函数:lambda函数是一种快速定义单行的最小函数，是从Lisp借用来的，可以用在任何需要函数的地方。

2.      使用lambda的好处

a)        使用Python写一些执行脚本时，使用lambda可以省去定义函数的过程，让代码更精简

b)        对一些抽象的，不会别的地方再复用的函数，有时候给函数起个名字也是个难题，使用lambda不需要考虑名字问题

c)        使用lambda在某些时候让代码更容易理解。

>>> l = range(1,6)

>>> l

[1, 2, 3, 4, 5]

>>> reduce(lambda x,y:x*y,l)//reduce实现一个函数，两两想乘，1*2*3*4*5

 

SWITCH

1.      python可以通过字典实现switch的功能。

2.      方法分两步

a)        定义一个字典

b)        其次，调用字典的get()获取相应的表达式

#coding:gbk

 

from __future__ import division

 

def jia(x,y):

   return x+y

def jian(x,y):

   return x-y

def cheng(x,y):

   return x*y

def chu(x,y):

   return x/y

 

operator ={"+":jia,"-":jian,"*":cheng,"/":chu}

 

def f(x,o,y):

   print operator.get(o)(x,y)

不需要多次通过if 和 elif来多次判断符号了。

常用内置对象

                  常用函数:

1.      abs():绝对值

2.      max():最大值

3.      min():最小值

4.      len():长度

5.      divmod():求两个数的商

6.      pow():求次方

7.      round():浮点数

8.      callable(f):测试f函数有没有被定义

9.      type():获取对象的类型

10.  isinstance(l,list):判断l是否为list

11.  cmp("hello","Hello"):比较两个字符串大小

内置函数

         String函数

1.       str.capitalize()

>>> s.capitalize() //把字符串s的首字母大写

2.      str.replace()

>>>s.replace("wangying","yingying")

>>> ss.replace("1","x",2)//2表示从头到尾替换几个1。

'x2x321123'

 

3.      str.split()  //str表示一个类别。

>>>ip = "196.168.0.1"

>>>l = ip.split('.')

>>>l

['196', '168', '0', '1']

>>>l = ip.split('.',2)//参数2表示切割几次

>>>l

['196', '168', '0.1']

可以导入string模块，其中也有string的各种处理方法

         序列处理函数

1.      len()

2.      max()

3.      min()

4.      filter()

>>>def f(x):

if x>5:

           return True

>>>l = range(10)

>>>filter(f,l)

[6, 7, 8, 9]

5.      zip()

>>>name=["yannis","wangying"]

>>>age = [23,20]

>>>tel = ["130","156"]

>>>zip(name,age,tel)

[('yannis', 23, '130'), ('wangying', 20, '156')]

>>>test = [1]  //zip组合以最小元组为基数

>>>zip(name,age,tel,test)

[('yannis', 23, '130', 1)]

 

6.      map()

>>>map(None,name,age,tel)

[('yannis', 23, '130'), ('wangying', 20, '156')]

>>>map(None,name,age,tel,test)

[('yannis', 23, '130', 1), ('wangying', 20, '156', None)]

map在某一个列表值不够的时候会以none代替。

>>>a = [1,2,3]

>>>b = [4,5,6]

>>>def f(x,y)

SyntaxError:invalid syntax

>>>def f(x,y):

return x*y

 

>>>map(None,a,b)

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

>>>map(f,a,b)

[4, 10,18]

>>> 

7.      reduce()

>>>def f(x,y):

return x+y

 

>>>l = range(100)

>>>reduce(f,l)

4950

>>>l = range(101)

>>>reduce(f,1)

 

Traceback(most recent call last):

  File "", line 1,in

    reduce(f,1)

TypeError:reduce() arg 2 must support iteration

>>>reduce(f,l)

5050

>>> 

>>>reduce(lambda x,y:x+y,l)

5050

 

>>>filter(lambda x:x%2 == 0 ,l)

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30,32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70,72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100]

 

九.  模块

1.      模块是python组织代码的基本方式

2.      python的脚本都是用扩展名为py的文本文件保存的，一个脚本可以单独运行，也可以导入另一个脚本中运行。当脚本被导入运行时，我们将其成为模块。

导入的模块如果要使用它的方法的话，需要这个模块名.这个方法。

print __name__会根据调用对象不同显示不同的值，如果本身的话就是main，如果器其他对象就显示被调用对象的方法名。

 

包:Python的模块可以按目录组织为包；创建一个包的步骤是:

a)      建立一个名字为包名字的文件夹

b)      在该文件夹下创建一个__init__.py文件

c)      根据需要在该文件夹下存放脚本文件、已编译扩展及子包

d)      import pack.m1, pack.m2,  pack.m3

具体步骤如下:

1.      在你安装Python目录C:\Python27\Lib\site-packages下创建一个文件夹MyModule(随意起名)

2.      __init__.py创建这个文件，不需要有内容。

3.      之后你的模块就可以放进去了，例如把scope.py放入

4.      >>> import MyModule.scope用这句话引入scope这个模块

总结:

1.      模块是一个可以导入的Python脚本文件

2.      包是一堆按目录组织的模块个子包，目录下的__init__.py存放了包的信息

3.      可以用import，import as ，from import等语句导入