python学习

Python的基本数据类型

1. Python的基本数据类型
   在Python里面，一个变量可以先后存储多种不同类型的数据。这是Python这类语言特有的特性，我们称之为动态语言，与之对应的是静态语言，Python、Javascript等等都是动态语言，Java、C、C++等等属于静态语言。

a = 1 # 这个时候a存储的是整数类型
print(a)
a = 'ABC' # 这个时候a存储的是字符串类型
print(a)

2. Python的整数与浮点数
   python中整数除法得到的结果是浮点数，Java则是自动保留整数部分，如果想要实现相同的功能则需要使用 ”// ”。

num1 = 10
num2 = 3
result = num1 / num2
print(result) # ==> 3.3333333333333335

10//3 # ==> 3

3. pyhton bool类型
   在Python中，布尔类型还可以与其他数据类型（字符串，数字等）做 and、or和not运算，Python把0、空字符串和None看成False，其他数值和非空字符串都看成True

a = True
print(a and 0 or 99) # ==> 99

Python字符串编码

1. 因为计算机只能处理数字，如果要处理文本，就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），所以，一个字节能表示的最大的整数就是255（二进制11111111=十进制255），0 - 255被用来表示大小写英文字母、数字和一些符号，这种编码方式被称为ASCII编码，比如大写字母 A 的编码是65，小写字母 z 的编码是122。
   如果要表示中文，显然一个字节是不够的，至少需要两个字节，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。
   类似的，日文和韩文等其他语言也有这个问题。为了统一所有文字的编码，Unicode应运而生。Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。
   Unicode通常用两个字节表示一个字符，原有的英文编码从单字节变成双字节，只需要把高字节全部填为0就可以。

Python 的容器：list，tuple，dic，set

1. Python 容器 元组(tuple)
   tuple和list不一样的是，tuple是固定不变的，一旦变成tuple，tuple中的每一个元素都不可被改变，同时也不能再往tuple中添加数据，而list是可以的，list 用[ ] ，tuple 用 ( ）。
   元组(tuple)的这个特性是非常重要的，在运行上tuple的性能是list的数倍。

L = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
print(L) # ==> ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
T = tuple(L)
print(T) # ==> ('Alice', 'Bob', 'Candy', 'David', 'Ellena')

1. (1).Python的不变tuple
   由于tuple一旦定义之后便不可修改，所以在实际编程中，tuple经常用于存放固定不变的数据。
   因此在使用上，tuple提供了便捷的方法可以访问tuple中的数据
   count()方法用来统计tuple中某个元素出现的次数。
   index()方法可以返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(1)) # ==> 3
print(T.count(5)) # ==> 1

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(9) # ==> 10
T.index(5) # ==> 8
T.index(1) # ==> 0 # 多次出现，返回第一次出现的位置

1. (2).Python的可变tuple
   tuple是不可变的，tuple里面的元素，也是不可替换的。但是这针对的是仅包含基础数据类型（数字类型、布尔类型、字符串类型）的数据，对于组合数据类型，则不受这个约束

T = (1, 'CH', [3, 4])
L = T[2]
print(L) # ==> [3, 4]
# 尝试替换L中的元素
L[1] = 40
print(L) # ==> [3, 40]
print(T) # ==> (1, 'CH', [3, 40])

这是因为虽然tuple中的list元素改变了，但是tuple本身指向的list仍然是同一个list，list本身并没有改变，改变的只是list里面的一个元素，这是tuple所约束不到的范围。

2. dict
   我们使用花括号{}表示这是一个dict，然后key和value之间使用冒号:分割，并且每一组key:value的最后，以逗号,表示这一组的结束。

d = {
    'Alice': 45,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 49
}

1. (1).key不可变
   对于基础数据类型，字符串、数字等，这些都是不可变的，可以作为dict的key，而对于复杂数据类型，经过前面的学习，我们知道tuple是不可变的，list是可变的，因此tuple可以作为dict的key，但是list不可以作为dict的key，否则将会报错
2. set
   set和list类似，拥有一系列元素，但是set和list不一样，set里面的元素是不允许重复的，而list里面可以包含相同的元素；set与list的另一个区别是，set里面的元素是没有顺序的。

Python 函数

1. 在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号()、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。
   我们以定义一个求绝对值的函数my_abs函数为例：

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

2. 除了返回None、一个值以外，Python函数也可以返回多个值，在函数中，如果需要返回多个值，多个值之间使用逗号分隔即可，但是需要注意顺序。

def data_of_square(side):
    C = 4 * side
    S = side * side
    return C, S

C, S = data_of_square(16)
print('周长 = {}'.format(C)) # ==> 周长 = 64
print('面积 = {}'.format(S)) # ==> 面积 = 256

3. Python函数参数
   函数参数可以是任意的数据类型，只要函数内部逻辑可以处理即可。
   但是，有时候由于函数的实现关系，需要特定的参数，就比如前面实现的求绝对值的函数my_abs()，如果传递一个字符串，就会引起错误。
   为了保证函数的正常运行，有时候需要对函数入参进行类型的校验，Python提供isinstance()函数，可以判断参数类型，它接收两个参数，第一个是需要判断的参数，第二个是类型。

def my_abs(x):
    if not isinstance(x, int) or not isinstance(x, float):
        print('param type error.')
        return None
    if x >= 0:
        return x
    else:
        return -x

4. Python函数可以使用默认参数，
   Java中不能像Python中这样做，但可以使用重载实现类似功能

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

class Function{
    public int power(int x, int n){
        s = 1;
        while(n > 0){
                n = n - 1;
                s = s * x;
        }
        return s;
        }
        //重载
    public int power(int x){
        s = 1;
        n = 2;
        while(n > 0){
                n = n - 1;
                s = s * x;
        }
        return s;
        }
        
      

    return s
    }
}

5. Python函数使用可变参数
   除了默认参数，Python函数还接收一种参数叫做可变参数，可变参数即任意个参数的意思，可变参数通常使用*args来表示。java 中没有该功能。
   可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple

def average(*args):
    sum = 0
    for item in args:
        sum += item
    avg = sum / len(args)
    return avg
average(1, 2) # ==> 1.5
average(1, 2, 2, 3, 4) # ==> 2.4

6. Python函数使用可变关键字参数
   而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

def info(**kwargs):
    print('name: {}, gender: {}, age: {}'.format(kwargs.get('name'), kwargs.get('gender'), kwargs.get('age')))

info(name = 'Alice', gender = 'girl', age = 16)