Python 主要数据类型和基本运算

变量规范： 字母、数字、下划线组成，不能以数字开头
命名规范： 只有类名是驼峰，其他都是小写字母，常量都是大写，下划线开头的都是私有。
只有符合命名规范的文件夹才是python package才能导入！！
使用from导入的时候后导入的会覆盖先前导入的同名文件。

#绝对导入
import part3

from part3.my_package import my_init_test

#相对导入 .代表当前目录  ..代表上一层目录
from .my_package import my_init_test

#as的作用
import part3.my_package.my_init_test as p

p.func()

Python的主要数据类型：

• Number，数值类型。python通过是否有小数点来区分int和float，python3中没有long
• String，字符串。主要用于描述文本
• List，列表。一个包含元素的序列
• Tuple，元组。和列表类似，但是不可变
• Set，集合。其中的元素是无序的
• Dict，字典。由键值对组成
• Boolean，布尔类型。值为True和False
• Byte，字节。例如一个字节流表示的jpg文件

注：
可变数据类型： 列表list和字典dict；
不可变数据类型： 整型int、浮点型float、字符串型string和元组tuple

基本运算：

#位运算

i = 11
j = 2
print(bin(i))
print(bin(j))

#按位与
z = i & j
print(z)

#按位或
x = i | j
print(x)

#按位异或
y = i ^ j
print(y)

#按位取反 加负号再减一
k = ~ i
print(k)
print(bin(k))

#移位运算符 左移右侧补零 右移右侧舍弃
c = i << 2
print(c)
print(bin(c))

d = i >> 2
print(d)
print(bin(d))

#输出a的ascii值
print(ord('a'))

a = 3, b = 2
print(a / b) # 1.5 结果是浮点数
print(a // b) # 1 结果只保留整数部分

a = 10 ** 3 # 乘方 1000
print(a)

补充：
Python3 详细的操作符优先级官方文档

条件控制：
python中使用and和or

and需要判断到最右一个，全为真才返回真

or只要碰到真值就返回真

---

字符串Srting：

#访问字符串中的子串 切片操作,区间左闭右开
print(s[0:6])

#字符串更新操作
s3 = "hello python"
s4 = "string"
print(s3[:6]+s4)

#字符串的成员运算 in   not in

#转义字符 \
print("\'")
print("\"")

#换行符
print("hello\npython")

#制表符
print("hello\tpython")

#回车 光标到行首，打印\r之后的内容
print("hello\rpython")

#原始字符串
print(r"hello\npython")
print(R"hello\npython")

#字符串的格式化输出，%s就是模板中的占位符，再提供一个元组，里面依次存放需要填入到 %s 位置的数据
print("我叫%s，今天是我第%d天学习python！" %('小明',10))

#字符串的内建函数
#查找
s = 'hello python'.find("o")
print(s)

#转换字母大小写
print("HELLO PYTHON".lower())
print("hello python".upper())

#返回字符串长度 这个长度是自然长度 从1开始
print("Hello Python".__len__())

#判断字符串是否只包含空格
print(" ".isspace())

#替换字符串
print("Hello python".replace("o","a"))

补充：

1.字符串前面加u：例如u'我这里想用中文'
后面字符串以Unicode格式进行编码，一般用在中文字符串前面，防止因为源码储存格式问题，导致再次使用时出现乱码。

2.字符串前面加r：使用原始字符串，去掉转义字符机制。

3.字符串前面加b：后面字符串是bytes 类型。

4.字符串前面加f：表示在字符串内支持大括号内的python 表达式:

print(f'{name} done in {time.time() - t0:.2f} s') 

# 输出
processing done in 1.00 s

获取字符串长度：
内置函数 len 可以用来获取字符串的长度，也是获取字符串中字符的个数：len(list1)
常用来获取 字符串、列表、元组、字典等类型对象的元素

find 方法:
会在字符串中查找参数字符串，并返回该参数字符串在其中第一个出现的位置索引

count 方法：
于统计字符串里某个字符出现的次数
'我们今天不去上学，我们去踢足球'.count('我们')

split 方法
split方法以参数字符串为分割符 ，将字符串切割为多个字符串，作为元素存入一个列表，并返回这个列表，分隔符本身在切割后，会被丢弃掉。

join 方法
和 split方法正好相反：

• split 是将字符串， 以 某字符串为界， 切割成多个字符串， 存入列表
• join 是将列表中的字符串元素以某字符串为连接符， 连接为一个字符串

splitlines()方法：
按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表

strip方法
将字符串前面和后面的空格删除，但是不会删除字符串中间的空格
lstrip方法 将 字符串前面 (左边) 的空格删除
rstrip方法 将 字符串后面 (右边) 的空格删除

isdigit 方法
检查字符串是否全部由数字构成，如果是，返回True，否则返回False

要得到一个字符串的倒序字符串，只需要使用切片操作 [::-1]
:: 表示切片字符串的从头到尾，也就是全部内容， 而 步长 为 -1 表示，颠倒过来取元素

f-string 格式化： 在python 3.6之后
在字符串模板前面加上f，然后占位符使用{} ,里面直接放入对应的数据对象。如下所示：

f'税前薪资是：{salary}元， 缴税：{tax}元， 税后薪资是：{aftertax}元'

---

列表List：

list1 = ['小明', 13, '小华', 15,'小张', 19]
print(type(list1))
print(list1)

#访问列表
print(list1[0])
print(list1[1:3])

#更新列表
list1[1] = 14
print(list1)

#列表添加
list1.append('小李')
list1.append(20)
print(list1)

list1 += ['狗蛋',25]
print(list1)

#列表删除
del list1[4]
print(list1)

#嵌套列表
list1 = [['小李','小张','小王'],[15,16,19]]
print(list1[0][2])

#访问列表元素的个数
count = len(list1[0])
print(count)

#移除列表中的元素,并且返回这个值
l = list1.pop(1)
print(l)
print(list1)

#对列表中的元素进行排序
list1 = [13,15,17]
list1.sort()
print(list1)

#查找列表中第一个匹配的元素的索引值
list2 = [12,13,11]
i = list2.index(11)
print(i)

#输出列表最右一个
print(list[-1])

#将列表逆置
list2 = list1.reverse()

---

元组Tuple：

在小括号内，不能修改

tuple1=('Google','Runoob','Taobao')

元组（Tuple）也是一种sequence特性的类型， 它和列表非常相似，也可以存放任何类型的数据对象，除了一点： 元组的内容是不能改变的

如果元组中只有一个元素，必须要在后面加上逗号，像这样a = (1, )

但是元组中的列表的内容却是可以改变的，比如

a = (1, 2, 3.14, 'hello', [7,8,9])
a[-1][0] = '你好'
print(a)

结果 a的值就变成了

(1, 2, 3.14, 'hello', ['你好', 8, 9])

判断元素是否在列表或元组中:
有时候，我们要检查列表、元组对象中是否存储我们要找的元素。 我们可以通过 in 这个关键字

---

集合Set：

'''
集合，无序的不重复元素的序列
两种声明方法 {} 和set()
'''

#声明一个集合
set_param = {"小李", "小张", "小陈", "小张"}
print(set_param)

#判断元素是否在集合内
print("小华" in set_param)
print("小陈" in set_param)

#两个集合间的运算
a = set('adndef')
b = set('sdcdef')

print(a & b)
print(a | b)
print(a ^ b)

#集合添加元素
my_set = set(('建国','卫国','国庆','爱国'))
my_set.add('建军')
print(my_set)

#移除指定元素
my_set.remove('国庆')
print(my_set)

#随机移除一个元素
pop_set = my_set.pop()
print(pop_set)
print(my_set)

#计算集合个数
print(len(my_set))

#清空集合
my_set.clear()
print(my_set)

---

字典Dict：

'''
字典 是一种可变容器，也是可以存储任意类型的对象 键值对（key，value）
'''

d = {'建国':12,'卫国':15,'国庆':19}
print(d)

#访问
keys = d.keys()
print(keys)
print(d['建国'])

#增加
d['小明'] = 14

#更新
d['建国'] = 20

#删除
del d['卫国']

补充： Python 3.6 改写了 dict 的内部算法，因此 3.6 的 dict 是有序的，在此版本之前皆是无序

字典按key排序：

    # sorted(key_value) 返回重新排序的列表
    # 字典按键排序
    for i in sorted (key_value) : 
        print ((i, key_value[i]), end =" ") 

字典按value排序：

print(sorted(key_value.items(), key = lambda kv:(kv[1], kv[0])))   

---

函数：

python没有重载，后面的同名函数会覆盖掉之前的函数

'''
函数定义的格式
'''

#
def my_func():
    pass

#关键字参数：是在调用的时候制定参数名称，可以不按照顺序传参数
def my_func(name,age):
    print(name +'他来了，他今年'+ str(age) +'岁')

my_func(age=12,name='老王')

#默认参数，如果调用者没有传值，那么就用默认值
def my_func(name='老王', age='30'):
    print(name + '他来了，他今年' + str(age) + '岁')
my_func()

#返回一个函数 不能有（）
def func_with_return(x):
    if x==2:
        def inner_func(y):
            return y * y
    if x==3:
        def inner_func(y):
            return y * y * y
    return inner_func

clc = func_with_return(3)
print(clc(4))

'''
递归
在函数中调用自己
重点：要明确递归结束的条件
优点：写法简洁
缺点：效率低
要求：每次递归的时候规模都要有所缩小
逻辑：每两次相邻的调用，前一次要为后一次做准备
'''

#阶乘计算
def my_func(x):
    if x == 1:
        return 1
    print('计算' + str(x) + '*' + str(x - 1))
    return x * my_func(x -1)

print(my_func(5))

特殊函数__name__：
只有在本模块启动时，__name__变量等于__main__
在什么时候使用：

1. 可以作为这个模块的入口，相当于其他语言的main函数
2. 可以作为调试使用，因为在其他地方调用本模块时，__name__==__main__判断结果为false 就不会执行