我要学python之python语法及规范

注释

单行注释： #
多行注释：
"""
写入注释内容
"""
'''
写入多行注释内容
'''

备注：python中单引号和双引号作用是一致的。

变量

python的命名规则与java或者C#命名规则是类似的，如下

变量命名规则：
1.变量名只能是字母、数字、下划线的任意组合
2.不能数字开头
3.关键字不能声明为变量

关键字

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
这些关键字可以进入交互模式下，然后引入keyword模块，输出keyword.kwlist

import keyword
keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

随着python的发展可能会改变，所以最新的关键字列表就用这种方式查看比较好。

输入

备注：在3.x后的版本和2.6之前的版本，有很多不同，所以在你操作时，先确认好版本。

#！/usr/bin/env python# -*- coding: utf-8 -*-# 2.x版本name = raw_input("请输入用户名:")#3.x版本name2 = input("请输入用户名:")#2.7和2.6属于过度版本，同时可以兼容上面两种写法，#但我觉得3.x才是未来，所以你可以不管以前的#打印输出名字#2.x版本print name#3.x版本print(name2)

流程控制

if...else
if...elif...else
while...
while...else
for...
for...else

这些流程控制上的我要觉得有点意思的是：
while...else
for...else
先来说结果：else块代码只有在while和for正常执行完成才会执行，如果break则不会执行。

比如现在我们来写个小程序，要求如下：
题目： 写一个python程序，实现猜数字值的功能，让用户输入一个数字，如果猜对了则输出bingo！如果猜错了，提示输入的数字相比目标数字更大还是更小，但最多使用3次机会。
下面我使用while演示一下简单逻辑：

#!/usr/bin/env python# -*- coding: utf-8 -*-#预设猜数值realnumber = 35#猜测数字次数times = 3#循环进行程序输入判断while times > 0:    target = int(input("请输入数字:"))    #判断是否与目标数值相等    if target == realnumber:        print("bingo!")        break    elif target > realnumber:        print("输入的值比目标值大!")    else:        print("输入数值比目标数值小!")    times -= 1else:    print("三次机会已经用完！")

基本数据类型

int \ long\ float\complex\布尔值\字符串\列表\元祖\字典

1.数值类型

int（整型）：取值-231~231-1
long （长整型）：-263~263-1
float（浮点型）：处理实数，类似于c的double类型，8字节
complex（复数）：一般形式：x+yj,x,y都是实数
备注：python中存在小数字池：-5 ~ 257, 类似于系统自带的常量池

2.布尔值

真和假（1和0）

3.字符串
与java类似的

4.列表

比如说：
namelist = ['a','b','c']
或者
namelist = list(['a','b','c'])
跟java、c#比，类似List
基本操作有：自行查阅相关文档

5.元祖

ages = (11,12,23,24)
或者
ages = tuple((11,12,23,24))
基本操作有：自行查阅相关文档
备注：
a.当定义一个单元素元组时，后面必须跟一个逗号，否则抛异常。
b.元祖中的元素不可修改，否则报：TypeError: 'tuple' object does not support item assignment

6.字典

person = {"name": "ckmike", "age": 23, "sex": "男"}
或者
person = dict({"name": "ckmike", "age": 23, "sex": "男"})
跟java、c#相比，类似于Map，它也是无序的
常用操作：自行查阅相关文档

7.set集合
set是一个无序且不重复的元素集合

keys = set({1,2,3,4})keys.add(2)keys.add(5)print(keys)

8.队列(Queue)
队列分双向队列(deque)和单向队列(Queue)。

class deque(object):    """    deque([iterable[, maxlen]]) --> deque object    Build an ordered collection with optimized access from its endpoints.    """    def append(self, *args, **kwargs): # real signature unknown        """ Add an element to the right side of the deque. """        pass    def appendleft(self, *args, **kwargs): # real signature unknown        """ Add an element to the left side of the deque. """        pass    def clear(self, *args, **kwargs): # real signature unknown        """ Remove all elements from the deque. """        pass    def count(self, value): # real signature unknown; restored from __doc__        """ D.count(value) -> integer -- return number of occurrences of value """        return 0    def extend(self, *args, **kwargs): # real signature unknown        """ Extend the right side of the deque with elements from the iterable """        pass    def extendleft(self, *args, **kwargs): # real signature unknown        """ Extend the left side of the deque with elements from the iterable """        pass    def pop(self, *args, **kwargs): # real signature unknown        """ Remove and return the rightmost element. """        pass    def popleft(self, *args, **kwargs): # real signature unknown        """ Remove and return the leftmost element. """        pass    def remove(self, value): # real signature unknown; restored from __doc__        """ D.remove(value) -- remove first occurrence of value. """        pass    def reverse(self): # real signature unknown; restored from __doc__        """ D.reverse() -- reverse *IN PLACE* """        pass    def rotate(self, *args, **kwargs): # real signature unknown        """ Rotate the deque n steps to the right (default n=1).  If n is negative, rotates left. """        pass    def __copy__(self, *args, **kwargs): # real signature unknown        """ Return a shallow copy of a deque. """        pass    def __delitem__(self, y): # real signature unknown; restored from __doc__        """ x.__delitem__(y) <==> del x[y] """        pass    def __eq__(self, y): # real signature unknown; restored from __doc__        """ x.__eq__(y) <==> x==y """        pass    def __getattribute__(self, name): # real signature unknown; restored from __doc__        """ x.__getattribute__('name') <==> x.name """        pass    def __getitem__(self, y): # real signature unknown; restored from __doc__        """ x.__getitem__(y) <==> x[y] """        pass    def __ge__(self, y): # real signature unknown; restored from __doc__        """ x.__ge__(y) <==> x>=y """        pass    def __gt__(self, y): # real signature unknown; restored from __doc__        """ x.__gt__(y) <==> x>y """        pass    def __iadd__(self, y): # real signature unknown; restored from __doc__        """ x.__iadd__(y) <==> x+=y """        pass    def __init__(self, iterable=(), maxlen=None): # known case of _collections.deque.__init__        """        deque([iterable[, maxlen]]) --> deque object        Build an ordered collection with optimized access from its endpoints.        # (copied from class doc)        """        pass    def __iter__(self): # real signature unknown; restored from __doc__        """ x.__iter__() <==> iter(x) """        pass    def __len__(self): # real signature unknown; restored from __doc__        """ x.__len__() <==> len(x) """        pass    def __le__(self, y): # real signature unknown; restored from __doc__        """ x.__le__(y) <==> x<=y """        pass    def __lt__(self, y): # real signature unknown; restored from __doc__        """ x.__lt__(y) <==> x a new object with type S, a subtype of T """        pass    def __ne__(self, y): # real signature unknown; restored from __doc__        """ x.__ne__(y) <==> x!=y """        pass    def __reduce__(self, *args, **kwargs): # real signature unknown        """ Return state information for pickling. """        pass    def __repr__(self): # real signature unknown; restored from __doc__        """ x.__repr__() <==> repr(x) """        pass    def __reversed__(self): # real signature unknown; restored from __doc__        """ D.__reversed__() -- return a reverse iterator over the deque """        pass    def __setitem__(self, i, y): # real signature unknown; restored from __doc__        """ x.__setitem__(i, y) <==> x[i]=y """        pass    def __sizeof__(self): # real signature unknown; restored from __doc__        """ D.__sizeof__() -- size of D in memory, in bytes """        pass    maxlen = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default    """maximum size of a deque or None if unbounded"""    __hash__ = None

单向队列

class Queue:    """Create a queue object with a given maximum size.    If maxsize is <= 0, the queue size is infinite.    """    def __init__(self, maxsize=0):        self.maxsize = maxsize        self._init(maxsize)        # mutex must be held whenever the queue is mutating.  All methods        # that acquire mutex must release it before returning.  mutex        # is shared between the three conditions, so acquiring and        # releasing the conditions also acquires and releases mutex.        self.mutex = _threading.Lock()        # Notify not_empty whenever an item is added to the queue; a        # thread waiting to get is notified then.        self.not_empty = _threading.Condition(self.mutex)        # Notify not_full whenever an item is removed from the queue;        # a thread waiting to put is notified then.        self.not_full = _threading.Condition(self.mutex)        # Notify all_tasks_done whenever the number of unfinished tasks        # drops to zero; thread waiting to join() is notified to resume        self.all_tasks_done = _threading.Condition(self.mutex)        self.unfinished_tasks = 0    def task_done(self):        """Indicate that a formerly enqueued task is complete.        Used by Queue consumer threads.  For each get() used to fetch a task,        a subsequent call to task_done() tells the queue that the processing        on the task is complete.        If a join() is currently blocking, it will resume when all items        have been processed (meaning that a task_done() call was received        for every item that had been put() into the queue).        Raises a ValueError if called more times than there were items        placed in the queue.        """        self.all_tasks_done.acquire()        try:            unfinished = self.unfinished_tasks - 1            if unfinished <= 0:                if unfinished < 0:                    raise ValueError('task_done() called too many times')                self.all_tasks_done.notify_all()            self.unfinished_tasks = unfinished        finally:            self.all_tasks_done.release()    def join(self):        """Blocks until all items in the Queue have been gotten and processed.        The count of unfinished tasks goes up whenever an item is added to the        queue. The count goes down whenever a consumer thread calls task_done()        to indicate the item was retrieved and all work on it is complete.        When the count of unfinished tasks drops to zero, join() unblocks.        """        self.all_tasks_done.acquire()        try:            while self.unfinished_tasks:                self.all_tasks_done.wait()        finally:            self.all_tasks_done.release()    def qsize(self):        """Return the approximate size of the queue (not reliable!)."""        self.mutex.acquire()        n = self._qsize()        self.mutex.release()        return n    def empty(self):        """Return True if the queue is empty, False otherwise (not reliable!)."""        self.mutex.acquire()        n = not self._qsize()        self.mutex.release()        return n    def full(self):        """Return True if the queue is full, False otherwise (not reliable!)."""        self.mutex.acquire()        n = 0 < self.maxsize == self._qsize()        self.mutex.release()        return n    def put(self, item, block=True, timeout=None):        """Put an item into the queue.        If optional args 'block' is true and 'timeout' is None (the default),        block if necessary until a free slot is available. If 'timeout' is        a non-negative number, it blocks at most 'timeout' seconds and raises        the Full exception if no free slot was available within that time.        Otherwise ('block' is false), put an item on the queue if a free slot        is immediately available, else raise the Full exception ('timeout'        is ignored in that case).        """        self.not_full.acquire()        try:            if self.maxsize > 0:                if not block:                    if self._qsize() == self.maxsize:                        raise Full                elif timeout is None:                    while self._qsize() == self.maxsize:                        self.not_full.wait()                elif timeout < 0:                    raise ValueError("'timeout' must be a non-negative number")                else:                    endtime = _time() + timeout                    while self._qsize() == self.maxsize:                        remaining = endtime - _time()                        if remaining <= 0.0:                            raise Full                        self.not_full.wait(remaining)            self._put(item)            self.unfinished_tasks += 1            self.not_empty.notify()        finally:            self.not_full.release()    def put_nowait(self, item):        """Put an item into the queue without blocking.        Only enqueue the item if a free slot is immediately available.        Otherwise raise the Full exception.        """        return self.put(item, False)    def get(self, block=True, timeout=None):        """Remove and return an item from the queue.        If optional args 'block' is true and 'timeout' is None (the default),        block if necessary until an item is available. If 'timeout' is        a non-negative number, it blocks at most 'timeout' seconds and raises        the Empty exception if no item was available within that time.        Otherwise ('block' is false), return an item if one is immediately        available, else raise the Empty exception ('timeout' is ignored        in that case).        """        self.not_empty.acquire()        try:            if not block:                if not self._qsize():                    raise Empty            elif timeout is None:                while not self._qsize():                    self.not_empty.wait()            elif timeout < 0:                raise ValueError("'timeout' must be a non-negative number")            else:                endtime = _time() + timeout                while not self._qsize():                    remaining = endtime - _time()                    if remaining <= 0.0:                        raise Empty                    self.not_empty.wait(remaining)            item = self._get()            self.not_full.notify()            return item        finally:            self.not_empty.release()    def get_nowait(self):        """Remove and return an item from the queue without blocking.        Only get an item if one is immediately available. Otherwise        raise the Empty exception.        """        return self.get(False)    # Override these methods to implement other queue organizations    # (e.g. stack or priority queue).    # These will only be called with appropriate locks held    # Initialize the queue representation    def _init(self, maxsize):        self.queue = deque()    def _qsize(self, len=len):        return len(self.queue)    # Put a new item in the queue    def _put(self, item):        self.queue.append(item)    # Get an item from the queue    def _get(self):        return self.queue.popleft()

运算符

1. 算数运算符：
   包括： 加减乘除（+ - * /），**(幂)，// 取商的整数部分，%取余数

2. 比较运算符：
   包括： ==， ！= , <> , > , < ,>=, <=

3. 赋值运算符：
   = 简单赋值
   += 加法赋值运算,下面的依次类推
   =
   /=
   =
   %=
   //=

4. 逻辑运算符：
   and 与
   or 或
   not 非

5. 成员运算符：
   in 判断指定序列中是否包含指定值
   not in

6. 身份运算符：
   is 判断两个标识是否引用自一个对象
   is not

7. 位运算符：
   位运算与java、c#等语言都是一样的

8.三元运算

result = 值1 if 条件 else 值2

备注：这些运算符的优先级，我不在这里进行书写，感兴趣的可自行查阅运算符优先级。