我要学python之python语法及规范

Love The Way You Lie 2022-01-10 11:13 227阅读 0赞

### 注释 ###

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

备注：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 -= 1
    else:
        print("三次机会已经用完！")

### 基本数据类型 ###

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

1.数值类型

int（整型）：取值-2**31~2**31-1  
long （长整型）：-2**63~2**63-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<y """
            pass
    
        @staticmethod # known case of __new__
        def __new__(S, *more): # real signature unknown; restored from __doc__
            """ T.__new__(S, ...) -> 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

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

转载于:https://blog.51cto.com/4837471/2176152

[Link 1]: http://www.runoob.com/python/python-operators.html