py-基本数据类型

#! /d/soft/python3/python.exe
""" Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。 

允许你同时为多个变量赋值

为多个对象指定多个变量
"""

from cmath import sqrt
from random import random, randrange, shuffle, uniform
from secrets import choice
import site
from winreg import DeleteValue


counter = 1
miles = 1000.0
name = 'hjj'

print(counter)
print(miles)
print(name)

a = b = 1
print(a)
print(b)

a, b = 1, 2
print(a)
print(b)

"""
Python3 中有六个标准的数据类型：
  Number（数字）
  String（字符串）
  List（列表）
  Tuple（元组）
  Set（集合）
  Dictionary（字典）

Python3 的六个标准数据类型中：

  不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
  可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）
"""

'''
Python3 支持 int、float、bool、complex（复数）。

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

像大多数语言一样，数值类型的赋值和计算都是很直观的。

内置的 type() 函数可以用来查询变量所指的对象类型。
'''

# 输出类型
a, b, c, d = 20, 3.4, True, 3+2j
print(type(a))
print(type(b))
print(type(c))
print(type(d))

# 判断类型
print(isinstance(a, int))

'''
isinstance 和 type 的区别在于：

  type()不会认为子类是一种父类类型。
  isinstance()会认为子类是一种父类类型。
'''

'''
Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断类型
'''
print(issubclass(bool, int))
print(True == 1)
print(False == 0)
print(True + 1)
print(False + 1)
print(1 is True)
print(0 is False)

# 删除变量
del a, b, c

# 数值运算
'''
1、Python可以同时为多个变量赋值，如a, b = 1, 2。
2、一个变量可以通过赋值指向不同类型的对象。
3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
4、在混合计算时，Python会把整型转换成为浮点数。
'''

print(5 + 1)
print(5 - 1)
print(5 * 1)
print(5 / 3)
print(5 // 3) # 浮点数
print(5 % 2)
print(5 ** 2)

# 字符串（略）

# 列表
""" 
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表

加号 + 是列表连接运算符，星号 * 是重复操作
"""

list = ['a', '123', True, 20.2]

tinyList = [123, 'hjj']

print(list)
print(list[0])
print(list[1:3])
print(list[2:])
print(list[0:-1])
print(list[0::2])
print(list + tinyList)
print(tinyList * 2)

# 与Python字符串不一样的是，列表中的元素是可以改变的

list[0] = 'b'

print(list)

list[0:2] = []

print(list)

# 元组 字符串是特殊的元组
""" 
string、list 和 tuple 都属于 sequence（序列）。

注意：

1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。
"""

tuple = ('abc', 123, 3.22, True, False, "hjj")
tinyTuple = ('123', 'aaa')
print(tuple)
print(tuple[0])
print(tuple[1:3])
print(tuple[1:])
print(tuple[1::2])
print(tinyTuple * 2)
print(tinyTuple + tuple)

tupleEmpty = ()
tuple20 = (20, )
print(tupleEmpty)
print(tuple20)

""" 
字符串：不可修改，可切割 '' "" * + [::]
元组：不可修改，可切割 () * + [::]
列表：可修改，可切割 [] * + [::]
"""

# 集合 有序

sitesEmpty = {}
print(sitesEmpty)
sites = set({1,2,3,4})
print(sites)
sites = {'baidu', 'google', 'bing', 'baidu'}
print(sites) # 过滤掉重复的值

if 'bing' in sites:
  print('bing in')
else:
  print('bing not in')

# 集合运算

a = set({'bb', 'nan', 'game', 'home'})
b = set({'jie', 'ge', 'game', 'home'})

print(a - b) # 差集，取a的不同
print(a | b) # 并集
print(a & b) # 交集
print(a ^ b) # a 和 b 不同时，存在的元素

# 字典
""" 
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。
"""

dictEmpty = {}
print(dictEmpty)
dictData = {}
dictData[0] = 'name'
dictData[1] = 'sex'
dictData['lang'] = 'ch'
print(dictData)
tinyDict = {'name': 'hjj', 'sex': 1}
print(dictData['lang'])
print(tinyDict.keys())
print(tinyDict.values())

tName = ('name', 'hjj')
tSex = ('sex', 1)
tLang = ('lang', 'ch')
lData = [tName, tSex, tLang]
dData = dict(lData)
print(dData)

print(dict(a=1,b=2,c=3))

# 推导
tDict = {x: x**2 for x in (2, 4, 6)}

print(tDict)

# 类型转换
""" 
隐式类型转换 - 自动完成, # 验证过不会自动转换，需要主动转换成可转换的指定类型。
显式类型转换 - 需要使用类型函数来转换
"""
n = 1
m = 1.1
print(n+m)
s = '1.2'
# s = '111'
# print(s+n) # 无法相加
# print(int(s)+n) # 会报错 
print(float(s)+n)

print(str(n) + s) # 拼接

# 函数
# number

a = -1
print(abs(a))
import math
print(math.ceil(9.1)) # 向上取整
print(math.floor(9.9)) # 向下取整
print(abs(-1.001))
print(math.fabs(-1.001))
print(min(1, 2))
print(max(1, 2))
print(pow(2, 8))
print(round(2.333, 2))
print(sqrt(9)) # complex

# 随机数
print(choice(range(10)))
print(randrange(0, 20, 2))
print(random())
print(int(random() * 10))
listData = [1,2,3,4,5]
shuffle(listData)
print(listData)
print(uniform(1, 100))
print(int(uniform(1, 100)))
print(math.pi)
print(math.e)

# 字符串 f-string f'{val}'

name = 'hjj'

print(f'Hello {name}')
print(f'{1+2}')
print(f'{1+2=}')

w = {'name': 'hjj', 'url': 'www.baidu.com'}

print(f'{w["name"]} {w["url"]}')

print(str.capitalize('HELLO WORLD'))
print(str.center('Game End', 10))

print(str.count('abc aab acc add', 'b'))

strings = '''
  a b c
'''
print(str.endswith('ba', 'a'))
print(str.expandtabs(strings, 2))
print(str.find(strings, 'aa')) # 返回index / -1
print(str.index(strings, 'b')) # 返回index / 报错
# strings = '''aaa@123'''
# strings = '''aaa 123'''
strings = '''aaa打123'''
print(str.isalnum(strings)) # 至少有一个字符，并且所有字符都是字母或者数字

strings = '''a打d'''
print(str.isalpha(strings)) # 至少有一个字符，并且所有字符都是字母或者中文字

strings = '123'
print(str.isdigit(strings)) # 数字

strings = 'abc'
print(str.islower(strings)) # 全小写

strings = 'ABC'
print(str.isupper(strings)) # 全大写

strings = '123'
print(str.isnumeric(strings)) # 全数字

strings = '      '
print(str.isspace(strings)) # 包含空白，必须是全部空白

strings = str.title('hjj') # 首字母大写
print(strings)
print(str.istitle(strings)) # 是否标题化

print(len(strings))

strings = 'ccc bbb aaa'
print('@'.join(strings))

strings = 'c'
print(strings.ljust(10, '1')) # 左对齐并且填充1到10位

strings = ' abc'
print(strings.lstrip())


print(str.maketrans('a', 'b'))

strings = 'abc'
print(max(strings))
print(min(strings))

strings = 'abc '
print(max(strings))
print(min(strings)) # 空格是最小字符串

strings = 'this is a iii '
print(strings.replace('i', 'b', 2)) # 替换

strings = 'HELLO world'
print(strings.swapcase()) # 替换

print(strings.split(' '))

strings = '''a
b
c d e
'''
print(strings.splitlines()) # 换行合并

strings = 'a, b, c'

# print( strings.translate() )

strings = 'abc'
print(';'.join(strings))

tupleData = ('a', 'b', 'c')
print(';'.join(tupleData))
tupleData = ['a', 'b', 'c']
print(';'.join(tupleData))
tupleData = {'a', 'b', 'c'}
print(';'.join(tupleData))

tupleData = (1, 2, 3) # 数字要循环转换后才行，不然报错
print(';'.join(str(i) for i in tupleData ))

l1 = [1,2]
l2 = [1,2]
import operator
print(operator.eq(l1, l2))


l = [1,2,3,4,5]
t = ('1','2','3','4')
# print(list(t)) # 无法转换
print(len(l))
print(min(l))
print(max(l))
l.append(1)
print(l)
lo = ['a', 'b']
l.extend(lo)
print(l)
print(l.index('a'))
l.insert(1, 'after')
print(l)
l.remove(2)
print(l)
l.pop()
print(l)
l.reverse()
print(l)

def takeSecond(e):
  return e

l = [1, 2, 3, 4, 5]
l.sort(key=takeSecond, reverse=False)
print(l)
l.sort(key=takeSecond, reverse=True)
print(l)

lc = l.copy()
print(lc)
l.clear()
print(l)

seq = ('a', 'b', 1)
d = dict.fromkeys(seq)

print(d)

d = {
  "a": 1,
  "b": 2,
  "c": 3,
  "d": {
    "e": 4,
    "f": {
      "g": 5
    }
  }
}
print(len(d))
print(str(d))
dc = d.copy()
print(dc)

print( d.get('a'), d.get('z', 'zzz') ) # dict.get(key, 默认值)

print('a' in d)
print(d.items()) # 视图对象
print(d.keys()) # 视图对象

d2 = {'x': 1}
d.update(d2)
print(d)

dp = d.pop('a') # 返回值
print(dp)

print(d)

print(d.popitem()) # 返回对象

print(d)

cc = {}

def addOne(c): 
  if c in cc:
    cc[c] += 1
  else:
    cc[c] = 1

addOne('a')
addOne('b')
addOne('a')

print(cc)
print(len(cc))

s = {
  'a',
  'b',
  'c'
}

s.add('d')
print(s)

sc = s.copy()
print(sc)
sc.clear()
print(sc)

s.discard('d')
print(s)
s.remove('a')
print(s)

s.pop() # 随机移除

print(s)

s.update('z') # 新增

print(s)

s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7, 8}

print(s1.difference(s2)) # 差集
s1.difference_update(s2) # 移除在s2中存在的元素
print(s1)

s1 = {1, 2, 3, 4, 5}

print(s1.intersection(s2)) # 交集
s1.intersection_update(s2)
print(s1)

s1 = {1, 2, 3, 4, 5}

print(s1.symmetric_difference(s2)) # 不重复的元素集合

s3 = {1}

print(s1.issuperset(s3)) # s3是否s1子集

# print(s3.isdisjoint(s1)) # 是否包含相同元素

print(s3.issubset(s1)) # s3是否s1子集

print(s1.union(s2)) # 并集

# 小结:
# 各种类型的方法和JS比较像. 和es6互相借鉴（抄袭）。有前端js基础的同学，更容易上手。