Python之路--Python基础1--数据类型

1、变量

　　Variables are used to store information to be referenced and manipulated in a computer program. They also provide a way of labeling data with a descriptive name, so our programs can be understood more clearly by the reader and ourselves. It is helpful to think of variables as containers that hold information. Their sole purpose is to label and store data in memory. This data can then be used throughout your program.

 

声明变量：

　　name = "Silence"      #次代码声明了一个变量，变量名为： name，变量name的值为："Silence"

tips：在Python中单行注释用    #注释内容

　　  多行注释用    　　　　　 '''注释内容'''

 

变量定义的规则：

　　一、变量名只能是字母、数字或下划线的任意组合

　　二、变量名的第一个字符不能是数字

　　三、标识符名称是对大小写敏感的。例如， myname 和 myName 不是一个标识符。注意前者中的小写 n 和后者中的大写 N 。

tips：变量是标识符的例子。标识符是用来标识某样东西的名字。

　　四、如下关键字不能声明为变量名：

　　['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

 

变量赋值：

name = "Silence_IOT" name2 = name
print(name,name2)

 

2、字符编码

　　python解释器在加载 .py 文件中的代码时，会对内容进行编码（默认ascill）

　　ASCII（American Standard Code for Information Interchange，美国标准信息交换代码）是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其余西欧语言，其最多只能用 8 位来表示（一个字节），即：2**8 = 256-1，因此，ASCII码最多只能表示 255 个符号。

 

关于中文

　　为了处理汉字，程序员设计了用于简体中文的GB2312和用于繁体中文的big5。

　　GB2312(1980年)一共收录了7445个字符，包括6763个汉字和682个其它符号。汉字区的内码范围高字节从B0-F7，低字节从A1-FE，占用的码位是72*94=6768。其中有5个空位是D7FA-D7FE。

　　GB2312 支持的汉字太少。1995年的汉字扩展规范GBK1.0收录了21886个符号，它分为汉字区和图形符号区。汉字区包括21003个字符。2000年的 GB18030是取代GBK1.0的正式国家标准。该标准收录了27484个汉字，同时还收录了藏文、蒙文、维吾尔文等主要的少数民族文字。如今的PC平台必须支持GB18030，对嵌入式产品暂不做要求。因此手机、MP3通常只支持GB2312。

　　从ASCII、GB23十二、GBK 到GB18030，这些编码方法是向下兼容的，即同一个字符在这些方案中老是有相同的编码，后面的标准支持更多的字符。在这些编码中，英文和中文能够统一地处理。区分中文编码的方法是高字节的最高位不为0。按照程序员的称呼，GB23十二、GBK到GB18030都属于双字节字符集 (DBCS)。

　　有的中文Windows的缺省内码仍是GBK，能够经过GB18030升级包升级到GB18030。不过GB18030相对GBK增长的字符，普通人是很难用到的，一般咱们仍是用GBK指代中文Windows内码。

 

3、用户输入

name = input("What is your name?") print("Hello ", name )

 输入密码时，若是想要不可见（就像Linux里面输入密码的时候同样），须要利用getpass 模块中的 getpass方法，即：

import getpass
  
# 将用户输入的内容赋值给 name 变量
pwd = getpass.getpass("请输入密码：")
  
# 打印输入的内容
print(pwd)

tips：getpass模块在PyCharm中很差使（程序会卡住），其余地方绝对好使

 

4、.pyc文件

一、解释型语言和编译型语言

　　计算机是不可以识别高级语言的，因此当咱们运行一个高级语言程序的时候，就须要一个“翻译机”来从事把高级语言转变成计算机能读懂的机器语言的过程。这个过程分红两类，第一种是编译，第二种是解释。

　　编译型语言在程序执行以前，先会经过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不须要翻译，而直接执行就能够了。最典型的例子就是C语言。

　　解释型语言就没有这个编译的过程，而是在程序运行的时候，经过解释器对程序逐行做出解释，而后直接运行，最典型的例子是Ruby。

　　经过以上的例子，咱们能够来总结一下解释型语言和编译型语言的优缺点，由于编译型语言在程序运行以前就已经对程序作出了“翻译”，因此在运行时就少掉了“翻译”的过程，因此效率比较高。可是咱们也不能一律而论，一些解

释型语言也能够经过解释器的优化来在对程序作出翻译时对整个程序作出优化，从而在效率上超过编译型语言。

　　此外，随着Java等基于虚拟机的语言的兴起，咱们又不能把语言纯粹地分红解释型和编译型这两种。

　　用Java来举例，Java首先是经过编译器编译成字节码文件，而后在运行时经过解释器给解释成机器文件。因此咱们说Java是一种先编译后解释的语言。

二、简述Python的运行过程

　　在说这个问题以前，咱们先来讲两个概念，PyCodeObject和pyc文件。

　　咱们在硬盘上看到的pyc天然没必要多说，而其实PyCodeObject则是Python编译器真正编译成的结果。咱们先简单知道就能够了，继续向下看。

　　当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。

　　当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，若是找到，则直接载入，不然就重复上面的过程。

　　因此咱们应该这样来定位PyCodeObject和pyc文件，咱们说pyc文件实际上是PyCodeObject的一种持久化保存方式。

 

5、数据类型

一、数字

　　2 是一个整数的例子。
       长整数 不过是大一些的整数。
　　3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 乘以10的-4次方。
　　(-5+4j)和(2.3-4.6j)是复数的例子，其中-5,4为实数，j为虚数，学过数学的人都知道。

int （整型）

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

 

tips：在Python中 ** 表示幂，例如2**32表示2的32次幂

 

long（长整型）

　　跟C语言不一样，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上因为机器内存有限，咱们使用的长整数数值不可能无限大。 　　注意，自从Python2.2起，若是整数发生溢出，Python会自动将整数数据转换为长整数，因此现在在长整数数据后面不加字母L也不会致使严重后果了。

float（浮点型）

      先扫盲 http://www.cnblogs.com/alex3714/articles/5895848.html 
　　浮点数用来处理实数，即带有小数的数字。相似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。

complex（复数）

　　复数由实数部分和虚数部分组成，通常形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

注：Python中存在小数字池：-5 ～ 257

 

二、布尔值

　　真或假

　　1 或 0

　　True 或 False

 

三、字符串

特性：不可修改

username = input("username:") password = input("password:") age = int(input("age:"))  #强制类型转换
print(type(age)) info = ''' ------username %s------- username:%s password:%s age:%d ''' % (username, username, password, age) info2 = ''' ------username2 {_username}------- username:{_username} password:{_password} age:{_age} '''.format(_username = username, _password = password, _age = age) info3 = ''' ------username3 {0}------- username:{0} password:{1} age:{1} '''.format(username, password, age) print(info3)

print("{0}dada{1}".format(name, age))

ID = "001"
print("2015", ID, "3921") #这样也能够

我的推荐使用info3方式的格式打印！！！

 

字符串经常使用功能：

name = "my name is Silence_IOT"

print(name.capitalize())        #首字母大写
print(name.count('i'))          #求个数
print(name.center(50, '-'))     #总共50个字符，把原字符串放中间，两边用-补齐
print(name.endswith("ei"))      #判断是否是以“ei”结尾
print(name.find("name"))        #返回索引
print(name[3:9])                #切片 返回第3个字符到第8个字符
print(name[3:])                 #切片 返回从第3个字符到结束


#print(name[name.find("name"):]) #切片 #print(name.expandtabs(tabsize=30)) #
 names = "my \tname is {name},{years} old"
print(names.format(name='alex', years=18)) print(names.format_map({"name": "Silence_IOT", 'years': '18'})) #单引号、双引号没多大区别



print("123ad".isalnum())        #判断是否为字母加数字
print("ad".isalpha())           #判断是否为纯英文字母

print("_ad".isidentifier())     #判断是否为合法标识符

print("123".isnumeric()) print("1".isdigit())            #判断是否为纯数字，有小数点都不行

print("123".isdecimal())        #判断是否为纯十进制数字

print("My Name Is".istitle())   #判断是否为标题，即每一个单词第一个是否大写

print("MY NAME".isupper())      #判断是否都是大写

print("+".join(["asd", '2', '3']))      #结果asd+2+3

print(name.ljust(30, '+'))              #结果my name is yanglei+++++++++++
print(name.rjust(30, '-'))              #结果-----------my name is yanglei

print(name.lower())              #所有变小写
print(name.upper()) print("1 \nAlex".lstrip())       #从左边开始去掉空格和回车
print("Alex \n1".rstrip())       #从右边开始去掉空格和回车
print(" \nAlex \n".strip())    #去掉空格和回车
 p = str.maketrans("adcdefghij", "0123456789")   #加密
print(name.translate(p))                        #结果my n0m4 8s y0n6l48

print("alex li".replace('li', 'L', 1))          #替换 #结果aLex Li

print("alex li".rfind('l'))          #查找最右边出现的那个元素的下标值 #结果5
print("alex li".find('l')) print("alex-li".split('-'))          #分割 #结果 ['alex', 'li']
print("al20ex\nli".splitlines())       #按换行符分割 #结果 ['alex', 'li']

print("Alex-Li".swapcase())          #大小写反转 #结果 aLEX-lI

print("alex li".title())             #把字符串变成title #结果 Alex Li

print("alex li".zfill())           #结果 0000000000000alex li

 

四、列表

建立列表：name_list = ['alex', 'seven', 'eric']

　　　　　　　　　　或

　　　　　 　name_list ＝  list(['alex', 'seven', 'eric'])

 

列表基本操做：

import copy #列表能够多层嵌套
names = ["YangLei", "ZhangYang",["YL", ["001010"], "OP"],  "LiJie", "GuYun", "123"] #增
names.append("Leijun")        #插入列表最后面
names.insert(1, "MaYun")      #将“MaYun”插入到下标为1的位置上

#删
names.remove("GuYun")                #删除"GuYun"这一项 #del names[2] <--> names.pop(2) #带下标数字二者相等
names.pop()                          #不带下标数字，删除列表最后一个元素


#修改
names[2] = "123"

#查找
print(names) print(names.index("123"))           #查找某元素的位置 #print(names[names.index("123")])
print(names.count("123"))           #查找某元素的数量 （列表里面的元素能够相同）
 list = [1, 33, 44, 456, 33] list.reverse() #反转列表元素的顺序
print(list)         #[33, 456, 44, 33, 1]
list.sort()                #排序,按照Ascll码排序
print(list)         #[1, 33, 33, 44, 456]
 names2 = [1,2,3,4] list.extend(names2) #把集合names添加到集合list 里面
print(list)                #[1, 33, 33, 44, 456, 1, 2, 3, 4]
 list2 = ["YangLei", "ZhangYang",["YL", ["001010"], "OP"],  "LiJie", "GuYun", "123"] #names3 = copy.deepcopy(names)  #深copy，数据所有不共享，就是彻底复制一份独立的数据 要import copy模块
names3 = list2.copy()           #浅copy，数据半共享，只复制第一层数据,第一层数据不变，深层的数据仍是引用原始数据
list2[1] = "11111111" list2[2][1] = "22222"
print(list2)     #['YangLei', '11111111', ['YL', '22222', 'OP'], 'LiJie', 'GuYun', '123']
print(names3)    #['YangLei', 'ZhangYang', ['YL', '22222', 'OP'], 'LiJie', 'GuYun', '123']
 list3 = [1, 44, 44, 545, 246, 4566, 55] print(list3[0:-1:2])         #切片[起始位置：结尾位置：间隔项数(n-1)] [1, 44, 246]
print(list3[::3])            #每隔2项去一次 [1, 545, 55]
print(list3[-1])             #打印倒数第1个 55
print(list3[0], list3[3])    #打印第一个和第三个 1 545
print(list3[0:3])   #切片 顾头不顾尾原则  [1, 44, 44]
print(list3[1:3])   #切片 [44, 44]

print(list3[-3:-1])   #还能倒着切 [246, 4566]
print(list3[-3:])     #切片 [246, 4566, 55]

 

五、元组

俗称不可变列表

建立元组：

ID = (11, 22, 33, 44, 55) 或 ID = tuple((11, 22, 33, 44, 55))

它只有2个方法，一个是count,一个是index，完毕。

 

六、字典

字典一种key - value 的数据类型，使用就像咱们上学用的字典，经过笔划、字母来查对应页的详细内容。

字典的特性：

• dict是无序的
• key必须是惟一的,so 天生去重

person = {"name": "mr.wu", 'age': 18} 或 person = dict({"name": "mr.wu", 'age': 18})

字典的基本操做：

info = { 'stu001': "LeiJun", "stu002": "MaYun", 'stu003': "Alex" } for i in info: print(i, info[i])  #最推荐使用的，循环打印字典


''' for k,v in info.items(): print(k,v) ''' b = { "stu001": "Alex", 1: 2, 3: 5 } info.update(b) #将字典b更新到字典info
print(info)     #{3: 5, 1: 2, 'stu002': 'MaYun', 'stu001': 'Alex', 'stu003': 'Alex'}

print(info.items())#dict_items([(3, 5), (1, 2), ('stu002', 'MaYun'), ('stu001', 'Alex'), ('stu003', 'Alex')])
 c = dict.fromkeys([1, 2, 3], "test")  #初始化新字典，1,2,3共享一个内存地址，value都是“test”
print(c)     #{1: 'test', 2: 'test', 3: 'test'}
 dict1 = { "stu001": "YL", 1: 2, 3: 5 } print(dict1.keys())          #打印全部的keys dict_keys([3, 1, 'stu001'])
print(dict1.values())        #打印全部的values dict_values([5, 2, 'YL'])

#首先查找，stu004,如有则返回原来字典里面stu004对应的value，没有则建立一个键值对，并返回值
print(dict1.setdefault("stu004", "YL")) #YL
print(dict1)  #{'stu001': 'YL', 'stu004': 'YL', 3: 5, 1: 2}
 dict1["stu001"] = "LJ"           #有Key，则修改value
dict1["stu005"] = "1234565"      #无Key，则建立新的键值对
print(dict1)    #{'stu005': '1234565', 1: 2, 'stu004': 'YL', 3: 5, 'stu001': 'LJ'}

#del dict1["stu001"] #删除
dict1.pop("stu005") print(dict1) dict1.popitem() #随便删除一个
print(dict1) #print(dict1["stu002"]) #没有就报错 print(dict1.get("stu006")) #没有就返回None 安全获取的方法

print("stu006" in dict1)        #查找是否有stu003,有就返回True

 

七、集合

集合是一个无序的，不重复的数据组合，它的主要做用以下：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据以前的交集、差集、并集等关系

集合经常使用操做：

list_1 = [1, 4, 5, 4, 7, 3, 6, 7, 6] list_1 = set(list_1)         #将列表转换为集合
list_2 = set([1, 5, 7, 6, 9, 11, 33])   #建立一个数值集合， 集合是无序的
list_5 = set("Hello")         #建立一个惟一字符的集合


print(list_1.intersection(list_2))  #求交集
print(list_1 & list_2)              #交集


print(list_1.union(list_2))         #求并集
print(list_1 | list_2)              #并集


print(list_1 - list_2)              #差集
print(list_1.difference(list_2))    #求差集 list_1中有，list_2中没有的元素
print(list_2.difference(list_1)) list_3 = set([1, 3, 7]) print(list_3.issubset(list_1))      #判断list_3是否是list_1的子集
print(list_1.issuperset(list_3))    #判断list_1是否是list_3的父集


#并集-差集=对称差集
print(list_1.symmetric_difference(list_2))  #项在两个集合中，但不会同时出如今两者中
print(list_1 ^ list_2)                      #对称差集 项在两个集合中，但不会同时出如今两者中
 list_4 = set([2, 4, 6]) print(list_3.isdisjoint(list_4))   #若是两个集合没有交集返回 True


#print(list_1.add(999)) 错误的写法
list_1.add(999)                 #添加一个项
list_1.update([123, 345, 455])  #添加多个项
print(list_1)