Python3学习（一）-基础、数据类型、变量、字符串和编码、list&tuple、if、for、while、dict、set、函数与参数

##廖雪峰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演变简写成这种样式的。