phtyon(一)基本数据类型，列表/字典/set，控制语句，函数

print(45678+0x12fd2);
print("Learn Python in imooc")
print(100 < 99)
print(0xff == 255)
print("hello, python")
#print语句也可以跟上多个字符串，用逗号“,”隔开，就可以连成一串输出
#遇到逗号“,”会输出一个空格
print("hello, ","python")
#转义
#\n 表示换行
#\t 表示一个制表符
#\\ 表示 \ 字符本身
s = "Python was started in 1989 by \"Guido\".\nPython is free and easy to learn."
print(s)
# raw 字符串 前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了,例：r'\(~_~)/ \(~_~)/'
#多行字符串，可以用'''...'''
print(r'''"To be, or not to be": that is the question.
Whether it's nobler in the mind to suffer.''')
# -*- coding: utf-8 -*-
print(u'''静夜思
床前明月光，
疑是地上霜。
举头望明月，
低头思故乡。''')
print('''Python的Unicode字符串支持"中文",
"日文",
"韩文"等多种语言''')
print('中文日文韩文')

#在Python中，布尔类型还可以与其他数据类型做 and、or和not运算，请看下面的代码：

#a = True
#print a and 'a=T' or 'a=F'
#计算结果不是布尔类型，而是字符串 'a=T'，这是为什么呢？

#因为Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True，所以：

#True and 'a=T' 计算结果是 'a=T'
#继续计算 'a=T' or 'a=F' 计算结果还是 'a=T'
#要解释上述结果，又涉及到 and 和 or 运算的一条重要法则：短路计算。

#1. 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。

#2. 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。

#所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果
a = 'python'
print('hello,', a or 'world')

b = ''
print('hello,', b or 'world')

集合

#Python内置的一种数据类型是列表：list,Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型
L = ["Adam", 95.5, "Lisa", 85, "Bart", 59]
print (L)

L1 = [95.5, 85, 59]
print(L1[0])
print(L1[1])
print (L1[2])
print (L1[-1])
print (L1[-2])
print (L1[-3])

#数组插入元素
L2 = ['Adam', 'Lisa', 'Bart']
L2.append('Paul')
L2.insert(2,'Paul')
print (L2)
#数组删除元素
L2.pop()
L2.pop(2)

#tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了
t = ('Adam', 'Lisa', 'Bart',)
print(t)
t0 = ('a', 'b', ['A', 'B'])
Lt = t0[2]
Lt[0] = 'X'
Lt[1] = 'Y'
print (t0)
t1 = ('a', 'b', ('A', 'B'))
print (t)

控制语句

score = 75
if score>=60:
    print ('passed')

score = 59
if not score>=60:
    print ('not passed')
if score >=60 :
    print ('passed')
else :
    print ('failed')

age = 20
if age >= 18:
    print ('adult')
else:
    print ('teenager')

score = 85

if score >= 90:
    print ('excellent')
elif score >= 80:
    print ('good')
elif score >= 60:
    print ('passed')
else:
    print ('failed')

#for循环 ，for item in L:
Lavg = [75, 92, 59, 68]
sum = 0.0
for item in Lavg:
    sum = sum + item
print (sum / 4)

sum = 0
x = 1
while x <= 100:
    if x%2==1 :
        sum = sum + x
        x = x + 1
print (sum)

#break用法
sum = 0
x = 1
n = 1
while True:
    if n>20:
        break
    sum=sum+x
    x=x*2
    n=n+1
print (sum)

sum = 0
x = 0
while True:
    x = x + 1
    if x > 100:
        break
    if x%2==0 :
        continue
    sum =sum +x
print (sum)

for x in [ 1,2,3,4,5,6,7,8,9 ]:
    for y in [ 2,3,4,5,6,7,8,9 ]:
        if x<y:
            print (x*10+y)

#dict
d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59,
    'Paul': 75
}
print(d)
if 'Paul' in d:
    print (d['Paul'])

#get 方法，在Key不存在的时候，返回None
#dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。
#不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢
print (d.get('Bart'))
d['Paul'] = 72
#dict内部是无序的，不能用dict存储有序的集合

#dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。
# 但是list是可变的，就不能作为 key
dict={
    '123': [1, 2, 3],  # key 是 str，value是list
    123: '123',  # key 是 int，value 是 str
    ('a', 'b'): True  # key 是 tuple，并且tuple的每个元素都是不可变对象，value是 boolean
}

#遍历
d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }
for key in d:
    print (key,':',d[key])

#默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()

s = set(['A', 'B', 'C'])
print(s)
print ('adam' in s)

#set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for x in s:
    print (x[0],':',x[1])

s = set(['Adam', 'Lisa', 'Paul'])
L = ['Adam', 'Lisa', 'Bart', 'Paul']
for item in L:
    if item in s:
        s.remove(item)
    else:
        s.add(item)
print (s)

函数

import operator

a=1
b=2
print(operator.lt(a, b))
operator.le(a, b)
print(operator.eq(a, b))
operator.ne(a, b)
operator.ge(a, b)
operator.gt(a, b)

#递归汉诺塔
def move(n, a, b, c):
    if n ==1:
        print (a, '-->', c)
        return
    move(n-1, a, c, b)
    print (a, '-->', c)
    move(n-1, b, a, c)
move(3, 'A', 'B', 'C')

#定义默认参数
def greet(name='world'):
    print ('Hello, ' + name + '.')
greet()
greet('Bart')

#定义可变参数，函数能接受任意个参数
def average(*args):
    sum = 0.0
    if len(args) == 0:
        return sum
    for x in args:
        sum = sum + x
    return sum / len(args)
print (average())
print (average(1, 2))
print (average(1, 2, 2, 3, 4))