if X:
    A = Y
else:
    A = Z

# 用于简单的if-else判断,基本语法：条件为真的返回值 if 条件 else 条件为假的返回值
A = Y if X else Z

a, b = b, a

# 附加

‘‘‘采用第三方变量‘‘‘
c = a
a = b
b = c

‘‘‘使用两个变量‘‘‘
a = a+b   #取两个数的和
b = a-b   #然后a-b等于a然后赋值给b
a = a-b   #然后a-b等于b然后赋值给a，完成值的交换

# 1. copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。
# 2. copy.deepcopy 深拷贝 拷贝对象及其子对象
import copy  
a = [1, 2, 3, 4, [‘a‘, ‘b‘]] #原始对象  
  
b = a #赋值，传对象的引用  
c = copy.copy(a) #对象拷贝，浅拷贝  
d = copy.deepcopy(a) #对象拷贝，深拷贝  
  
a.append(5) #修改对象a  
a[4].append(‘c‘) #修改对象a中的[‘a‘, ‘b‘]数组对象  
  
print ‘a = ‘, a  
print ‘b = ‘, b  
print ‘c = ‘, c  
print ‘d = ‘, d  

# 输出结果：
a = [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘], 5]
b = [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘], 5]
c = [1, 2, 3, 4, [‘a‘, ‘b‘, ‘c‘]]
d = [1, 2, 3, 4, [‘a‘, ‘b‘]] 

v = dict.fromkeys([‘k1‘,‘k2‘],[])? 
v[‘k1’].append(666)
?print(v)?         >>{‘k1‘: [666], ‘k2‘: [666]}
v[‘k1’] = 777
?print(v)       >> {‘k1‘: 777, ‘k2‘: [666]}

#正序
for i in range(1,10):
    for j in range(1,i+1):
        print("%s*%s=%s" % (j,i,i*j),end="\t")
    print()

#倒序
for i in range(9,0,-1):
    for j in range(i,0,-1):
        print("%s*%s=%s" % (j,i,i*j),end="\t")
    print()

#一行代码
print("\n".join("\t".join(["%s*%s=%s" % (y, x, x*y) for y in range(1, x + 1)]) for x in range(1, 10)))

“1,2,3”.split(‘,‘)

[int(i) for i in “1,2,3”.split(‘,‘)]

>>> b = [(1),(2),(3) ]
>>> print(type(b[1]))
<class ‘int‘>
>>> b = [(1,),(2,),(3,) ]
>>> print(type(b[1]))
<class ‘tuple‘>
>>> b = [1,2,3]
>>> print(type(b[1]))
<class ‘int‘>

[pow(i,2) for i in range(1,11)]

def distFunc1():
    a=[1,2,4,2,4,5,6,5,7,8,9,0]
    b={}
    b=b.fromkeys(a)
    print b
    #print b.keys()
    a=list(b.keys())
    print a
    
def distFunc2():
    a=[1,2,4,2,4,5,7,10,5,5,7,8,9,0,3]
    a=list(set(a)) # set是非重复的，无序集合。可以用list来的排队对set进行排序，list()转换为列表，a.sort来排序
    print a
    
def distFunc3():
    #可以先把list重新排序，然后从list的最后开始扫描，代码如下：
    List=[1,2,4,2,4,5,7,10,5,5,7,8,9,0,3]
    if List:
        List.sort()
        #print List
        last = List[-1]
        #print last
        for i in range(len(List)-2, -1, -1):
            if last==List[i]: 
                del List[i]
            else: last=List[i]

# coding:utf-8 

class Stack(object):
    def __init__(self):
        self.__list = []

    def push(self, item):
        """添加一个新元素到栈顶"""
        self.__list.append(item)

    def pop(self):
        """弹出栈顶元素"""
        return self.__list.pop()

    def peek(self):
        """返回栈顶元素"""
        if self.__list:
            return self.__list[-1]
        else:
            return None

    def is_empty(self):
        """判断栈是否为空"""
        return self.__list == []

    def size(self):
        """返回栈元素个数"""
        return len(self.__list)


if __name__ == ‘__main__‘:
    s = Stack()
    s.push(0)
    s.push(1)
    s.push(2)
    print(s.pop())

>>> print("我叫%s，今年%d岁了" % ("小李", 20))
我叫小李，今年20岁了


1、正常使用

>>> print("我叫{}，今年{}岁了".format("小李", 20))
我叫小李，今年20岁了

2、还可以通过在括号里填写数字，修改格式化的顺序

>>> print("我叫{1}，今年{0}岁了".format("小李", 20))
我叫20，今年小李岁了

3、通过key取变量

>>> print("我叫{name}，今年{age}岁了".format(name="小李", age=20))
我叫小李，今年20岁了

# coding:utf-8

# 二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，
# 且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，
# 将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成
# 前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。
# 重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。


    # 最优时间复杂度：O(1)
    # 最坏时间复杂度：O(logn)

def binary_search(alist, item):
    first = 0
    last = len(alist)-1
    while first<=last:
        midpoint = (first + last)//2
        if alist[midpoint] == item:
            return True
        elif item < alist[midpoint]:
            last = midpoint-1
        else:
            first = midpoint+1
    return False
testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
print(binary_search(testlist, 3))
print(binary_search(testlist, 13))


def binary_search(alist, item):
    if len(alist) == 0:
        return False
    else:
        midpoint = len(alist)//2
        if alist[midpoint]==item:
          return True
        else:
          if item<alist[midpoint]:
            return binary_search(alist[:midpoint],item)
          else:
            return binary_search(alist[midpoint+1:],item)

testlist = [0, 1, 2, 8, 13, 17, 19, 32, 42,]
print(binary_search(testlist, 3))
print(binary_search(testlist, 13))

n = 0
for i in range(1,6):
    for j in range(1,6):
        for k in range(1,6):
            if( i != k ) and (i != j) and (j != k):
                n += 1
print("能组成%d个互不相同且无重复数字的三位数："%n)

class Solution(object): 
    def twoSum(self, nums, target): 
        """ :type nums: List[int] 
            :type target: int 
            :rtype: List[int] 
        """ 
        if len(nums) <= 1: 
            return False 
            buff_dict = {} 
            for i in range(len(nums)): 
                if nums[i] in buff_dict: 
                    return [buff_dict[nums[i]], i] 
                else: 
                    buff_dict[target - nums[i]] = i

import json
dict = {‘aa‘: ‘你好啊‘, ‘bb‘: ‘你还‘}
print  dict
print ‘-----------------------‘
##加上ensure_ascii=False后data返回的就是中文而不是unicode
data = json.dumps(dict, ensure_ascii=False)
‘‘‘
方法二：
print json.dumps(dict,ensure_ascii=False).decode(‘utf8‘).encode(‘gb2312‘)
‘‘‘
print data

####
python3中没有这种问题，所以最简单的方法是引入future模块
from __future__ import unicode_literals

print json.dumps(dict,ensure_ascii=False)

=>{"aa": "你好啊"}

#方法1：使用os.listdir
import os
for filename in os.listdir(r‘c:\windows‘):
    print filename
 
#方法2：使用glob模块，可以设置文件过滤
import glob
for filename in glob.glob(r‘c:\windows\*.exe‘):
    print filename
 
#方法3：通过os.path.walk递归遍历，可以访问子文件夹
import os.path
def processDirectory ( args, dirname, filenames ):
    print ‘Directory‘,dirname
    for filename in filenames:
        print ‘ File‘,filename
 
os.path.walk(r‘c:\windows‘, processDirectory, None )
 
#方法4：非递归
import os
for dirpath, dirnames, filenames in os.walk(‘c:\\winnt‘):
    print ‘Directory‘, dirpath
    for filename in filenames:
        print ‘ File‘, filename

# 另外，判断文件与目录是否存在
import os
os.path.isfile(‘test.txt‘) #如果不存在就返回False
os.path.exists(directory) #如果目录不存在就返回False