##廖雪峰py3笔记

## '//'这是获得相除后的整数部分

##a = 10//3

##print (a)

## '/'获得相除后的结果，为浮点数，结果能整除也也是浮点数

##b = 10/3

##print(b)

##c = 9/3

##print (c)

##输入输出

##name = input('please enter your name:')

##print('hello,',name)

##结果：

##please enter your name:jianweiwei

##hello, jianweiwei

##编码

##美国字母数据是用的ascii编码，占用一个字节，unicode 是世界公用编码，占用4个字节，Utf_8是新的

##国际编码标准，可以根据字符所的编码难易程序，来分配对应的长度，如，在Utf-8中，英文字母是占用1个字节，

##中文占用3个字节。

##py字符串

##对于单个字符的编码，ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符。

##ord('a')#97

##print(ord('a'))

##print(ord('中'))#20013

##print(chr(88))#X

##print(chr(25991))#文

##py的字符串类型是str,在内存中以Unicode表示，一个字符对应若干个字节，如果要在网络上传输，或者保存到

##保存到磁盘上，就需要把str变为以字节为单位的bytes.

##对bytes类型的数据用带b前缀的单引号或双引号表示：

##x = b'ABC'#表示bytes类型的数据，每个字符只占一个字节，‘ABC’表示str字符串，用Unicode编码

##print(x)#结果：b'ABC'

##以Unicode表示的str通过encode()(编码)方法可以编码为指定的bytes,例如：

##x = 'ABC'.encode('ascii')

##print(x)#结果b'ABC'，表示把str类型的'ABC'编码为b'ABC'的以字节为单位的bytes类型的

##x = '中文'.encode('utf-8')

##print(x)#结果：b'\xe4\xb8\xad\xe6\x96\x87'，把中文变成了bytes.

##x = '我爱大树'.encode('utf-8')

##print (x) #b'\xe6\x88\x91\xe7\x88\xb1\xe5\xa4\xa7\xe6\xa0\x91'

##纯英文的str可以用ASCII编码为bytes,含有中文的str可以用utf-8编码为bytes,含有中文的str无法用ASCII编码，因为

##中文编码范围超过了ASCII的。在bytes中，无法显示为ASCII的字节，用\x##表示，

##反过来，如果我们从网络或磁盘上读取了节节流，那么读的数据就是bytes。要把bytes转为str,yi

##需要用decode()方法

##x = b'ABC'.decode('ascii')

##print (x)#结果ABC,说明已经把字节的b'ABC'转化为str的'ABC'

##x = b'\xe6\x88\x91\xe7\x88\xb1\xe5\xa4\xa7\xe6\xa0\x91'.decode('utf-8')

##print (x) #我爱大树'

##len()用来计算str字符串的字符数，还可以来用计算bytes数据的字节数。

##print (len(b'ABC'))#3说明，一个bytes占用一个字节，而一个英文字符占用1个字节。一个中文占用3个字节

##print (len('ABC'))#3

##print (len(b'\xe6\x88\x91\xe7\x88\xb1\xe5\xa4\xa7\xe6\xa0\x91'))#12

##py源码也是文本文件，当源码中包含中文时，在保存源码时，就需要务必指定保存为utr-8可以在文件开头时写上

##   #!/usr/bin/env python3

##   #-*- coding:utf-8 -*-

##上面第一行是为了告诉Linux/osx系统，这是一个py可执行程序，在windows可以不用写，第二行是说用utf-8读取代码。

##py中的格式化，用%实现。

##strHi = 'hello,%s'%'world'#在前面字符串中的%s被后面%后的字符串替换。

##print (strHi)

##当要替换的内容比较多时，后面的%号用括号括起来，用,进行分隔。

##常见的点位符有：

##%d 整数

##%f 浮点数

##%s 字符串

##%x 16进制整数

##其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数。

##x = '%2d-%02d' % (3,1)

##print (x)# 3-01

##x = '%.2f' % 3.1415926

##print (x)#3.14

##当为了表示在字符中的一个普通的'%',可以用%%来进行转义，

##练习

##x = (85-72)/72*100

##print('小明的成绩提升了%.1f%%'%x) #小明的成绩提升了18.1%

##py中的list

##classmates = ['a','b','c','d','e']#用[]表示。

##x = len(classmates)#用len()函数可以得到list的长度，前面也可以得到str,bytes的长度，字节数量

##print(x)#5

##print(classmates[2])#可以得到指定位置上的元素c。

##print(classmates[len(classmates)-1])#list最后一个元素用len(list)-1来表示位置。

##print(classmates[-1])#e,也可能用-1来表示最后一个元素，同理[-2]表示最后第二个。

##classmates.append('f')#把f加到最后一个位置上

##classmates.insert(1,'0')#把0加入到索引为1的位置。

##classmates.pop()#删除最后一个元素。

##classmates.pop(3)#删除指定位置为3的元素。

##classmates[2] = 'k'#把索引位置为2的元素换为'k'

##print(classmates)

####list中也可以添加另一个list

##classmates.insert(1,[1,3,4])

##print(classmates)

##print(classmates[1])

##

##a = []

##print(len(a))#0,表示空的list

##tuple元组，有序列表，一旦初始化就不能修改，这样数据更安全，所以能用tuple不用list

##classmates = ('x','y','z')

##print(classmates[0])#'x'

###由于tuple不能被修改，所以list中的insert,pop,等一些修改，替换的方法在元组中都不能用。

#当定义的为一个元素时

##t = (1)#这时与数据运算中()会有歧义，Py规定这时按数学运算记，t为1.而不是元组。可以改变。

##tupleDemo = ('1','23',[22,33])#表示一个元组里包含一个list,这时元组的元素还是不能改变，但是元组中的list

#元素的内容是改变的，应该加以区分。

####练习

##L = [['apple','google','microsoft'],['java','py','puby','php'],['adam','bart','lisa']]

##print(L[0][0])

##print(L[1][1])

##print(L[2][2])

##条件判断：if,和java同，就不再详细记录主要是注意格式,缩进。

##if x :

##    print()

##elif y :

##    if l :

##        print()

##    elif m :

##        print()

##    else :

##        print()

##else :

##    print()

##for循环，py中的for循环与java中的超级for循环类似，把要循环的对象分别赋值给变量。

##ziMu = ['a','b','c','d']

##for zi in ziMu :

##    print(zi) #a b c d

##range(i)生成一个从0到小于i的一个整数序列。

##sum = 0

##for ii in range(100):

##    sum = sum+ii

##print (sum)

##while循环

##while x:

##    print()

##    if l:

##        break

##dict全称是dictionary字典，在java中被称为map,有健值对。查找速度快，是能过健值查找，比list快。

##d = {'a':111,'b':222,'c':333,'d':444}

##d['a']#111.

###d[f]因为没有f这个健，所以会报错，因此可以用下面方法：

##if 'f' in d :

##    print(d['f'])

###或

##d.get('f')#当’f'不存在时，会返回None

###要删除一个key,用

##d.pop('c')#同时，'c'对应的value值也会被删除掉。

##list与dict相比，dict的特点：

#1.查找与插入速度快，不会随着key的增加变慢。

#2.要占用大量的内存，

#list则查找与插入时间会随元素数量的增加而增加。但内存占用相对较少。

#dict的key不能改变，不然得到的value的内存位置就会改变，value也会改变。因此作为key的类型为

#不可以改变的类型，str,整型，但list不能作为key.

####set

###也是 组key的集合，但不存储value，像在dict中一样，key同样不能重复。要创建set，需要提供一个list作为

###输入集合

##s= set([1,2,3,4,5,3443])

##print(s)#{1, 2, 3, 4, 5, 3443},可以看到是大括号，list是[]。同时，set中的元素是无序的。

###set会自动过滤list中的重复元素。

##q = set([1,1,1,3,3,3,2,2,222222,5,5,])

##print(q)#{1, 2, 3, 5, 222222}可以看到，重复元素被过滤了，

##q.remove(222222)#

##print(q)#{1, 2, 3, 5}用remove(key)来删除一个key

###因为set中的元素不能重复，所以可以为两个序列取交集，并集操作。

##s1 = set([1,2,3])

##s2 = set([2,3,4])

###取交集

##print(s1 & s2)#{2, 3}

###取并集

##print(s1 | s2)#{1, 2, 3, 4}

###set与dict一样，不可以放入可变对象，因为无法判断两个可变对象是否相等。

###尝试把list放入set

###s1[0] = [1,2,3]#TypeError: 'set' object does not support item assignment

###print (s1[0])

###不可变对象：

###str是不可变对象，list是可变对象。

##a = ['b','a','d','e','c']

##a.sort()

##print(a)#['a', 'b', 'c', 'd', 'e'],a变成有序的了，说明内容可变。

##a = 'abc'

##a.replace('a','A')

##print (a)#abc,说明a没有变，但是没有变为是可以使用replace()方法呢。

##a = 'abc'

##b = a.replace('a','A')

##print(b)#Abc,可以理解为：a只是一个变量，指向一个内存地址，其中放着字符串'abc',a.replace('a','A')

###方法没有改变'abc',而是重新生成一个新的字符串'Abc',b指向了这个新的字符串，a还是指向'abc'

####函数

##x = -2

##abs(x)#求绝对值，当传入的参数的个数不对，会报Typeerror错误。

##y = 5

##max(x,y)

###数据类型转换

##print(int('123'))#123,把str类型的’123‘转换为整数123

##print(float('12.34'))#12.34

##print(str(12.34))#'12.34',

##print(bool(1))#True

##print(bool(''))#False

###像abs()函数中的abs函数名称实际是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于

###给函数起了个别名。

##a = abs

##print(a(-30))

##b = max

##print(b(18,80))

####练习

##print(str(hex(30)))#0x1e,把30转换成16进制表示的字符串。

####函数的定义

###Py中函数定义用def 函数名(参数)：函数体，return 返回值

##def my_abs(x):

##    if x>=0:

##        return x

##    else :

##        return -x

##print(my_abs(-10))

###py中可以传入多个参数，并且有多个返回值。

##def manyData(a,b,c):

##    x = b+c

##    y = a+b

##    z = a+c

##    return x,y,z

##print(manyData(1,2,3))#返回的多个参数是以元组的形式返回的。

###return,当return后，函数就被结束了执行，当return None,返回就是为空,也可以写成return

###空函数：

###pass,当函数体为空时，可以用pass结束，返回为None,用pass语句什么都不做，点位符用。当还没有想

###想好函数体怎么写是，用pass.

##def getAge(age):

##    if age>=10:

##        pass

##getAge(13)

###当调用 一个函数时，传入的参数是一个错误的类型，或参数的个数不对时，就会报TypeError错误。

##def my_abs1 (x):

##    if not isinstance(x,(int,float)):

##        raise TypeError('bad operand type')

##    if x>=0:

##        return x

##    else :

##        return -x

####print(my_abs1('11'))#当传入的参数类型不正确时，就会报raise 后面的定义的错误。

##print(my_abs1(-11))

##函数的参数

#位置参数

def power(x,n):

    s = 1

    while n>0:

        s = s*x

        n = n-1

    return s

print(power(12,3))#这里的x,n都是被指定好位置的，叫位置参数。调用时，要依次传入参数。

#默认参数

def moren(x,n = 3):

    s = x+n

    return s

print (moren(1))#4,这里可以看到，函数定义了两个参数，但调用函数时，只传入了一个参数，n没有

#传入参数值，但也没有报错，原函数里的 n=3就是默认参数，当不传入n的参数值时，就使用默认值，

#而传入n的参数值时，就会使用传入的参数。

print(moren(1,10))#11

print(moren(3))

#默认参数一般放在函数非默认参数的后面，默认参数一般为变化量不大的参数。

#默认参数必须指向不变的对象，上面n = 3,是把n 指向3这个不变的数字。

#当默认参数指向一个可变的对象时：

def kebian(b = []):

    b.append('X')

    return b

print(kebian())#['X']

print(kebian())#['X', 'X'],可以看到，当默认参数指向一个可变对象时，执行同样语句，内容确

#有变化，这是什么原因呢：因为变量b指向对象[]的引用地址，地址不会变，但[]中的内容是可变的,

#当第一次执行参数时，[]list,内容就变成了['x']，再次执行时，就会往同一地址指定的[]中再加入一

#次'x',这样就会导入不希望出来的结果。

#可变参数

def kebian(*nums):#接收时用'*'加一个变量名，表示接收可变参数。

    s = 0;

    for num in nums:

        s = s+num

    return s

print(kebian(1,3,4,3,2,3,3))#可变参数就是用来表示参数个数不确定的函数。传入的参数，是由

#list或tuple演变简写成这种样式的。