Python的语法基础你真的了解吗_Python

Python语法基础

01-Python快速入门

U1-定义变量

直接定义不用指明变量类型

e.g:

				?

									a=10

U2-判断语句

				?

									#coding=utf-8

									if s>=80:

									    print("优")

									elif s>=60:

									    print("良")

									else:

									    print("差")

必须要有缩进！！

有中文要强调下utf-8

U3-循环

				?

									for i in range(0,100):

									    print(i)

									for i in range(0,100):

									    print("Item {0}".format(i))

									print("Item {0},{1}".format(i,"Hello Python"))

U4-定义函数

				?

									def sayHello():

									    print("Hello World")

									def max(a,b):

									    if a>b:

									        return a

									    else:

									        return b

									sayHello()

									print(max(2,3))

U5-面向对象

class Hello:

				?

									def sayHello(self):

									    print("Hello Python")

									h = Hello()

									h.sayHello()

class Hello:

				?

									def _init_(self,name):

									    self._name = name

									def sayHello(self):

									    print("Hello {0}".format(self._name))

#继承Hello类,要执行父类的构造方法

class Hi(Hello):

				?

									def _init_(self,name):

									    Hello._init_(self,name)

									def sayHi(self):

									    print("Hi {0}".format(self._name))

									h = Hello("tan")

									h.sayHello()

									h1 = Hi("ther")

									h1.sayHi()

U6-引入python文件

1)mylib.py:

				?

									class Hello:    

									    def sayHello(self):

									        print("Hello Python")

2)loadlib.py:

				?

									import mylib

									h = mylib.Hello()

									h.sayHello()

									from mylib import Hello

									h = Hell0()

									h.sayHello()

02-python的三大优点、七大特色

U1-三大优点：

简单、功能强大、支持面向对象

U2-七大特色：

大小写严格区分

简单、易学、支持面向对象

开源

库非常丰富

跨平台使用

解释性语言

高级语言

03-python语法基础

U1：Python常量与变量

常量：在程序运行的时候不会被更改的量，一旦绑定，就不能更改

Python中定义常量需要用对象的方法来创建

const.py（要放在lib文件下，lib主要放些模块化的东西）:

				?

									#class _const(object):

									class ConstError(TypeError): pass

									def __setatter__(self, name, value):

									    if self.__dict__.has_key(name):

									        raise self.ConstError, "Can't rebind const(%s)" % name

									    self.__dict__[name] = value

									def __delattr__(self, name):

									    if name in self.__dict__:

									        raise self.ConstError, "Can't unbind const(%s)" %name

									    raise NameError, name

									import sys

									sys.modules[__name__] = _const()

									#changliang.py:

									import const

									const.value=5

									print const.value

									const.value=6

变量：在程序运行时可以随着程序的运行更改的量，即使赋值，也可以更改

				?

									i = 7

									print i

									i = 7

									print i

									i += 1

									print i

									i += 2

									print i

U2：Python数与字符串

				?

									5种数：

									    int 整数型

									    long 长整数型，e.g: 878123l

									    float 浮点型，e.g: 1.71235

									    bool 布尔型，e.g: True、False

									    complex 复数型，e.g: 3+5j、2-7j

									字符串：用引号引起来的字符集

									引号的使用与区别：

									    单引号里面可以使用双引号，并且可以输出出来

									    双引号里面不能使用双引号，但是其里面可以使用单引号，并且可以输出出来

									    三引号（三个单引号或者三个双引号），三引号引起来的内容可以换行

									转义符

									    \: 不会解析单引号里面的单引号或者双引号里面的双引号

									    e.g: print 'It\'s a dog!'

									    \n: 转行

									    e.g: print "hello tan\nhello tan"

									自然字符串：

									    在python里面，如果我们的一串字符串即使有转义符，也需要将他原样保留，不进行任何处理，我们可以使用自然字符串，就在字符串前面加上r

									e.g:

									    #自然字符串

									    print "hello tan\nhello tan"

									    print r"hello tan\nhello tan"

									    输出：

									    hello tan

									    hello tan

									    hello tan\nhello tan    

									字符串的重复：

									    如果要将一个字符串重复的输出，可以使用字符串的重复运算符，例如将hi重复输出7次，可以使用"hi"*7

									print "Hello World\n"*7

									子字符串：

									    想取一个字符串中的子字符串出来，就要进行子字符串运算，子字符串的运算方法主要有两种：1.索引运算法[] 2.切片运算法[:]

									#子字符串

									#索引运算符从0开始索引

									#切片运算符[a:b]是指从第a下标开始到第b-1下标。同样，从0开始索引

									    s1 = "helloworld"

									    s2 = s1[0]

									    s3 = s1[7]

									    s4 = s1[:7]

									    s5 = s1[7:]

									    s6 = s1[3:7]

									    print s6

U3：Python数据类型

				?

									基本数据类型：数和字符串

									列表

									    在python中没有数组的概念，python中跟数组最接近的概念就是列表和元组。列表就是用来存储一连串元素的容器。列表用[]来表示，在列表中的元素是有序排列的，并且从0号元素开始。

									    #列表

									    drinks=["可口可乐","百事可乐","雪碧","芬达","美年达"]

									    print drinks[1]

									元组

									    元组里面的元素也是进行索引计算

									    列表与元组的区别：1.列表里面的元素的值是可以修改的，但是元组里面的元素的值不能修改，只能进行读取操作                    2.列表的符号是[],而元组的符号是()

									    #元组

									    drinks=("可口可乐","百事可乐","雪碧","芬达","美年达")

									    print drinks[1]

									    #不能修改否则报错

									    drinks[1] = "兰芳园"

									    print drinks[1]

									集合

									    python中集合主要有两个功能，一个功能是建立关系，另一个功能是消除重复元素，集合的格式是：set(元素)

									    #集合

									    a=set("asfddseegsak")

									    b=set("sfca")

									    #交集

									    c=a&b

									    print c

									    #并集

									    d=a|b

									    print d

									    #差集

									    e=a-b

									    print e

									    #去除重复元素

									    new=set(a)

									字典

									    python中的字典也叫做关联数组，用大括号{}括起来。格式：

									        zidian={'name':'tan','location':'china','like':'sleep'}。

									    字典里面包含了一整个事情，这一整个事情里面包括了各种方面的详细信息。比如上述的就包含了name、location、like这三个方面的具体信息。

									    #字典

									    d={"姓名":"tan","国家":"中国"}

									    print d["国家"]

									    #添加字典里面的项目

									    d["爱好"]="睡觉"

									    print d["姓名"]

									    print d["爱好"]

U4：Python标识符

				?

									命名规则：

									    1.标识符第一个字符必须是字母或者下划线，第一个字符不能出现数字或者其他的字符

									    2.标识符除了第一个字符外，其他部分可以说字母或者下划线或者数字

									    3.标识符大小写敏感

									    python中的关键字是指系统中自带的具备特定含义的标识符。

									    常用的python关键字有：

									        and

									        elif

									        global

									        or

									        else

									        pass

									        break

									        continue

									        import

									        class

									        return

									        for

									        while

									        print

U5：Python对象

				?

									什么是python的对象?

									    在python中一切皆为对象，内置的对象类型主要包括数组、字符串、列表、元组、字典、集合等

									详解pickle腌制

									    在python中如果需要对一些对象进行持久性存储，并且不丢失这个对象的类型与数据，则需要将这些对象进行序列化，序列化之后，需要使用的时候，我们再恢复变成之前的数据。序列化的这个过程，我们将其称为pickle（腌制）

									    #pickle腌制

									    import pickle

									    #dumps(object)将对象序列化

									    lista=["one","two","three"]

									    listb=pickle.dumps(lista)

									    print listb

									    #loads(string)将对象原样恢复，并且对象类型也恢复为原来的格式

									    listc=pickle.loads(listb)

									    print listc

									    #dump(object,file)将对象存储到文件里面序列化

									    group1=("four","five","six")

									    f1=file("1.pk1","wb")

									    pickle.dump(group1,f1,True)

									    f1.close()

									    #load(object,file)将dump()存储在文件里面的数据恢复

									    f2=file('1.pk1','rb')

									    t=pickle.load(f2)

									    print t

									    f2.close()

U6：Python行与缩进

				?

									了解逻辑行与物理行:

									    逻辑行主要是指一段代码在意义上的行数，物理行是指实际中看到的行数

									    #逻辑行与物理行

									    #2个物理行

									    print "123"

									    print "345"

									    #1个物理行,2个逻辑行

									    print "123";print "345"

									    #1个逻辑行,2个物理行

									    print '''你好吗

									    你还好吗'''

									行中分号使用规则:

									    在python中一个物理行一般可以包括多个逻辑行，在一个物理行中编写多个逻辑行的时候，逻辑行与逻辑行之间用分号隔开。每个逻辑行的后面必须是有一个分号的，但是如果一个逻辑行占了一个物理行的最后，这个逻辑行可以省略分号。

									行连接:

									    在不使用三引号的情况下，还可以使用行连接去占取多行（即：将一个逻辑行写在多个物理行中）

									    #行连接

									    print '杀青散\

									    没有解药'

									什么是缩进?

									    python有一个很不一样的不同点，在python中逻辑行行首的空白是有规定的，逻辑行行首的空白不对，便会导致程序执行出错

									    报错：There's an error in your program:unexpected indent

									如何缩进

									    1.一般情况下逻辑行行首不应该出现空白

									    2.if语句的缩进方法

									    3.while循环的缩进方法

									    #缩进

									    #一般情况下，行首不应该出现空白

									    import sys

									    #缩进的方法有两种，一种按空格，另一种按tab键

									    #if语句的缩进方法

									    a=7

									    if a>0:

									        print "hi"

									    #while循环的缩进方法

									    a=0

									    while a<7:

									        print a

									        a+=1

									注释:

									    在python中一般使用#进行注释，#是单行注释