print('I'm ok.')
转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\表示的字符就是\
如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r''表示''内部的字符串默认不转义
print(r'\\t\') # \\t\
如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容
print('''line1
...line2
..line3...''')
line1
...line2
..line3...
布尔值:
True与False
*and为与 两个判断同为True或False时and才执行
print(5 > 3 and 5 >4) #True
*or为或,一个判断为True则返回True
*not非,把True变成False，False变成True. print(not 1 > 2) #True
空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
除法:/浮点型,//整除,%取余
ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符
纯英文的str可以用ASCII编码为bytes，内容是一样的，含有中文的str可以用UTF-8编码为bytes。含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错。
在bytes中，无法显示为ASCII字符的字节，用\x##显示。
(此处应注意,不能多或少空格,否则会报错)
'ABC'.encode('ascii')
b'ABC'
'中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
b'ABC'.decode('ascii')
'ABC'
b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'
算str包含多少个字符，可以用len()函数：>>> len('ABC')
3
len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数,一个中文字符经过utf-8编码时,通常会占用3个字节,而一个英文字符只占用一个字符
len(b'ABC')
3
len(b'\xe4\xb8\xad\xe6\x96\x87')
6
len('中文'.encode('utf-8'))
6
注:python的源代码也是一个文本文件,所以当源码中包含中文的时候,在保存源码时,就需要指定保存为UTF-8编码, 需要在文件开头加
!/usr/bin/env python3
-- coding: utf-8 --
%运算符是用来格式化字符串的
'Hi, %s, you have $%d.' % ('Michael', 10000)
'Hi, Michael, you have $10000.'
%d 整数
%f 浮点数
%s 字符串
%x 十六进制整数
当%作为一个字符存在时,用%%表示
'growth rate: %d %%' % 7
'growth rate: 7 %'
list 和 tuple
list就是oc中的数组
classmates = ['Michael', 'Bob','Lili']
classmates
['Michael', 'Bob', 'Lili']
//插入
classmates.insert(1, 'Jack')
classmates
['Michael', 'Jack', 'Bob', 'Lili']
// 删除
pop,pop()默认删除最后一个元素pop(1)删除指定索引处
//替换
classmates[0] = 'Liu'
classmates
['Liu', 'Jack']
// 可以有不同的元素
L = ['Apple', 123, True]
L
['Apple', 123, True]
// 一个数组也可以包含其他数组
s = [L,classmates]
s
[['Apple', 123, True], ['Liu', 'Jack']]
tuple
有序列表,一旦初始化就不能修改,tuple和list的区别就是一个可变一个不可变,类似于nsarray与namutablearr
else和if语句没有写成功,这里标记一下...
for name in names:
print(name)
mic
bob
nancy
sum = 0
for x in [1,2,3,4,5,6,7]:
sum = sum + x
print(sum)
1
3
6
10
15
21
28
range()可以生成一个整数序列,从0开始
list(range(5))
[0, 1, 2, 3, 4]
sum = 0
for x in range(101):
sum = sum + x
print (sum)
// 5050
Dictionary
和list比较，dict有以下几个特点：
查找和插入的速度极快，不会随着key的增加而变慢；
需要占用大量的内存，内存浪费多。
而list相反：
查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法。
set
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
s = set([1,2,3])
s
{1, 2, 3}
注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。
// 重复参数会被过滤
s = set([1,2,3,11,34,2,3,3])
s
{1, 2, 3, 34, 11}
// 添加
s.add(4)
s
{1, 2, 3, 34, 4, 11}
// 删除
s.remove(4)
s
{1, 2, 3, 34, 11}
set可以看成数学意义上的无序和无重复元素的集合,两个set可以做数学意义上的交集,并集等操作
s1 = set([1,2,3])
s2 = set([2,3,4])
s1 & s2
{2, 3}
s1 | s2
{1, 2, 3, 4}
set和dic的区别为没有存储对应的value,共同点为同样不可以放入可变对象,无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”.
定义函数时，需要确定函数名和参数个数；
如果有必要，可以先对参数的数据类型做检查；
函数体内部可以用return随时返回函数结果；
函数执行完毕也没有return语句时，自动return None。
函数可以同时返回多个值，但其实就是一个tuple。
def my_abs(x):
if not isinstance(x, (int, float)):
s
[['Apple', 123, True], ['Liu', 'Jack']]
#####tuple
有序列表,一旦初始化就不能修改,tuple和list的区别就是一个可变一个不可变,类似于nsarray与namutablearr
#####else和if语句没有写成功,这里标记一下...
>>> for name in names:
print(name)
mic
bob
nancy
>>> sum = 0
>>> for x in [1,2,3,4,5,6,7]:
sum = sum + x
print(sum)
1
3
6
10
15
21
28
range()可以生成一个整数序列,从0开始
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> sum = 0
>>> for x in range(101):
sum = sum + x
print (sum)
// 5050
#####Dictionary
和list比较，dict有以下几个特点：
查找和插入的速度极快，不会随着key的增加而变慢；
需要占用大量的内存，内存浪费多。
而list相反：
查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法。
set
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
>>> s = set([1,2,3])
>>> s
{1, 2, 3}
注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。
// 重复参数会被过滤
>>> s = set([1,2,3,11,34,2,3,3])
>>> s
{1, 2, 3, 34, 11}
// 添加
>>> s.add(4)
>>> s
{1, 2, 3, 34, 4, 11}
// 删除
>>> s.remove(4)
>>> s
{1, 2, 3, 34, 11}
set可以看成数学意义上的无序和无重复元素的集合,两个set可以做数学意义上的交集,并集等操作
>>> s1 = set([1,2,3])
>>> s2 = set([2,3,4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
set和dic的区别为没有存储对应的value,共同点为同样不可以放入可变对象,无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”.
定义函数时，需要确定函数名和参数个数；
如果有必要，可以先对参数的数据类型做检查；
函数体内部可以用return随时返回函数结果；
函数执行完毕也没有return语句时，自动return None。
函数可以同时返回多个值，但其实就是一个tuple。
>>> def my_abs(x):
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x >= 0:
return x
else:
return -x
my_abs('C')
Traceback (most recent call last):
for name in names:
print(name)
mic
bob
nancy
>>> sum = 0
>>> for x in [1,2,3,4,5,6,7]:
sum = sum + x
print(sum)
1
3
6
10
15
21
28
range()可以生成一个整数序列,从0开始
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> sum = 0
>>> for x in range(101):
sum = sum + x
print (sum)
// 5050
#####Dictionary
和list比较，dict有以下几个特点：
查找和插入的速度极快，不会随着key的增加而变慢；
需要占用大量的内存，内存浪费多。
而list相反：
查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法。
set
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
>>> s = set([1,2,3])
>>> s
{1, 2, 3}
注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。
// 重复参数会被过滤
>>> s = set([1,2,3,11,34,2,3,3])
>>> s
{1, 2, 3, 34, 11}
// 添加
>>> s.add(4)
>>> s
{1, 2, 3, 34, 4, 11}
// 删除
>>> s.remove(4)
>>> s
{1, 2, 3, 34, 11}
set可以看成数学意义上的无序和无重复元素的集合,两个set可以做数学意义上的交集,并集等操作
>>> s1 = set([1,2,3])
>>> s2 = set([2,3,4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}
set和dic的区别为没有存储对应的value,共同点为同样不可以放入可变对象,无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”.
定义函数时，需要确定函数名和参数个数；
如果有必要，可以先对参数的数据类型做检查；
函数体内部可以用return随时返回函数结果；
函数执行完毕也没有return语句时，自动return None。
函数可以同时返回多个值，但其实就是一个tuple。
>>> def my_abs(x):
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x >= 0:
return x
else:
return -x
>>> my_abs('C')
Traceback (most recent call last):
File "<pyshell#38>", line 1, in <module>
my_abs('C')
File "<pyshell#37>", line 3, in my_abs
raise TypeError('bad operand type')
TypeError: bad operand type
my_abs(1)
1
计算x2的函数：
def power(x):
return x * x
power (5)
25
n次方
def power(x, n):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
power(5,2)
25
设置默认值
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
power (5)
25
power (5, 3)
125
定义默认参数:
def add_end(L=[ ]):
L.append('END')
return L
add_end([1,2,3])
[1, 2, 3, 'END']
add_end()
['END']
add_end()
['END', 'END']
所以，定义默认参数要牢记一点：默认参数必须指向不变对象！我们可以用None这个不变对象来实现：
def add_end(L=None):
if L is None:
L = []
L.append('End')
return L
add_end()
['End']
add_end()
['End']
因为不变对象一旦创建，对象内部的数据就不能修改，这样就减少了由于修改数据导致的错误。此外，由于对象不变，多任务环境下同时读取对象不需要加锁，同时读一点问题都没有。我们在编写程序时，如果可以设计一个不变对象，那就尽量设计成不变对象。
