我要学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 -= 1
else:
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()运算符
算数运算符：
包括： 加减乘除（+ - * /），**(幂)，// 取商的整数部分，%取余数比较运算符：
包括： ==， ！= , <> , > , < ,>=, <=赋值运算符：
= 简单赋值
+= 加法赋值运算,下面的依次类推
=
/=
=
%=
//=逻辑运算符：
and 与
or 或
not 非成员运算符：
in 判断指定序列中是否包含指定值
not in身份运算符：
is 判断两个标识是否引用自一个对象
is not- 位运算符：
位运算与java、c#等语言都是一样的
8.三元运算
result = 值1 if 条件 else 值2
备注：这些运算符的优先级，我不在这里进行书写，感兴趣的可自行查阅运算符优先级。
网站题目：我要学python之python语法及规范
URL地址：http://scyanting.com/article/pdoddp.html
