首页 > 编程语言> > Python入门看这一篇就够了

Python入门看这一篇就够了

2020-12-06 20:01:46 作者：互联网

Python的注释

# 单行注释
'''
多行注释
多行注释
'''
"""
多行注释
多行注释
"""

Python变量的命名规范

变量名可以使用字母、数字、下划线_，
但不能以数字开头
严格区分大小写
不要使用中文
不要使用系统关键字
变量名必须有含义

# 查看python的关键字
import keyword
kw = keword.kwlist
print(kw)

练一练

下列命名方式错误的是？
A. $name = 123
B. _name = ‘小明’
C. 1name = True
D. name1 = “张三”
E. imput = 请输入

答案：ACE

Pyhton变量的定义

a = 10
b = 20
# 需要交换a、b变量的值，即 a=20 b=10
'''
普通方式，完成变量数据的交换
1.把a变量的值 赋值给c，此时 c变量中 就是 10
2.把b变量的值 赋值给a，此时 a变量中 就是 20
3.把C变量的值 赋值给b，此时 b变量中 就是 10
''' 
c = a  # c = 10
a = b  # a = 20
b = c  # b = 10
print(a,b)  # a = 20 b = 10
'''
利用python定义比变量的语法来实现 变量的数据交换
'''
a,b = b,a
print(a,b)  # a = 20 b = 10

简单介绍python的数据类型的定义

Python数据类型

String字符串类型

# String字符串定义
love = 'iloveyou'
hello = '你好 世界'
like = "i like you"

# 大字符串定义
str = '''
    床前明月光，
    疑似地上霜。
    举头望明月，
    低头思故乡。
'''

在python中提供了一个方法，用于获取当前变量的数据类型，type() 函数，返回一个数据或变量的数据类型结果

str = 'ilikeyou'
print(type(str))  # <class 'str'> str == string

单双引号可以互相嵌套

str = "i 'like' you"
str = 'i "like" you'

同类型引号可以使用转义字符

# 转义字符
str = 'i \'like\' you'
str = "i \"like\" you"

# \n 换行 \t 制表
str = '床前\n明月光'
str = r'床前\n明月光' # r可以取消转义字符的作用

Number数字类型

int 整型
float 浮点型
complex 复数
boolean 布尔类型(True、False)

# 定义
varInt = 521  # 整数
varInt = -1314  # 整数
varFloat = -13.14  # 浮点数
varNum = 0x10  # 十六进制
varNum = b'00010101'  # 二进制
varComplex = 5 + 6j  # 复数
varBool = True  # 布尔
varBool = False  # 布尔

List列表

列表用来表示一系列数据
列表中存储的数据可以时任意类型的
在需要记录多个数据时，可以使用中括号进行定义 []
并且每个数据之间使用逗号分隔 ,

varList = [192,168,200,68]
print(varList,type(varList))

列表中存储的数据，可以通过下标的方式进行获取

'''
  0   1  2    3    4
['a','b',531,'pai',3.1415926]
'''
varList = ['a','b',531,'pai',3.1415926]
print(varList[0])  # a
print(varList[3])  # pai
print(varList[4])  # 3.1415926

二级列表（二维列表）或者多级列表（多维列表）

'''
 0  1  2   3            4  5  6
[1, 2, 3, [11, 22, 33], 5, 6, 7]
           0   1   2
'''
varList = [1,2,3,[11,22,33],5,6,7]
print(varList[3][0])  # 11
print(varList[3][1])  # 22
print(varList[3][2])  # 33

Tuple元组

元组使用小括号进行定义()
元组的最大特点就是值不能被改变

'''
 0 1 2  3   4
(1,2,3,'a','b')
'''
varTuple = (1,2,3,'a','b')
print(varTuple,type(varTuple))
print(varTuple[3])  # a

元组的几种定义方式

# 方式一
# 注意：如果元组中只有一个元素，那么需要加, 
varTuple = (123,)

# 方式二
varTuple = 1,2,3

# 方式三
varTuple = (1,2,3)

元组与列表的区别

列表使用中括号定义
元组使用小括号定义
列表中的值可以修改
元组中的值不可修改

# 列表
varList = [1,2,3]
# 修改下标为1的元素的值
varList[1] = 22
print(varList)  # [1,22,3]

# 元组
varTuple = (1,2,3)
# 修改下标为1的元素的值
varTuple[1] = 22
print(varTuple)
# TypeError: 'tuple' object does not support item assignment

Dict字典

字典也是用于存储一组或多组数据时使用
字典是键值对的存储方式 name : 'admin’
键和值之间使用英文冒号进行分隔，多组键值对之间使用逗号分隔
键必须是字符串或数字类型，值可以是任意类型
键名不能重复，值可以重复

# 字典的定义
varDict = {
    'title':'<<鬼谷子>>',
    'author':'鬼谷子',
    'price':'29.9'}
print(varDict,type(varDict))  
# {'title': '<<鬼谷子>>', 'author': '鬼谷子', 'price': '29.9'} <class 'dict'>

# 获取字典中的值
print(varDict['title'])  # <<鬼谷子>>

# 字典中的键不能重复使用，否则前面的数据会被后面的数据覆盖
varDict = {'a':10,'b':10,'c':20,'a':'aa'}
print(varDict)
# 覆盖前 {'a':10,'b':10,'c':20,'a':'aa'}
# 覆盖后 {'a': 'aa', 'b': 10, 'c': 20}

~~小提醒：在python之前的版本中，字典是无序的~~

Set集合

set集合是一个无序且元素不重复的集合的数据类型
set集合使用大括号{}或者set()方法来定义
set集合无法获取单个元素
set集合可以添加删除，无法更新

# 集合的定义方式
varSet = {1,2,3,'a','b',1}
varSet = set('1234567')

如果需要定义一个空集合时 只能使用 set()方法

varS = {}  # 空字典
varSet = set()  # 空集合

集合添加元素

setA = {1,2,3,'a'}
setA.add('b')
print(setA)  # {1, 2, 3, 'b', 'a'}

删除元素

setA.discard('a')
print(setA)  # {1, 2, 3, 'b'}

检查当前的元素是否在集合中

print(1 in setA)  # True

拓展

集合可用于运算，交集、差集、并集、对称差集

交集：(A & B) A、B共有的元素
差集：(A - B) A有、B无的元素，反之(B - A) B有、A无的元素
并集：(A | B) A、B合并，去重
对称差集：(A ^ B) A、B集合不共有的元素

# 示例
setA = {1,2,3,'a','b'}
setB = {1,'a',22,33}
'''
交集
{1,2,3,'a','b'}
&
{1,'a',22,33}
====> (A & B) A、B共有的元素
{1,'a'}
'''
res = setA & setB
print(res)  # {1, 'a'} 

'''
差集
{1,2,3,'a','b'}
-
{1,'a',22,33}
====> (A - B) A有、B无的元素
{2，3，'b'}
'''
res = setA - setB
print(res)  # {2，3，'b'}

'''
差集
{1,'a',22,33}
-
{1,2,3,'a','b'}
====> (B - A) B有、A无的元素
{22,33}
'''
res = setB - setA
print(res)  # {22,33}

'''
并集
{1,2,3,'a','b'}
｜
{1,'a',22,33}
====> (A | B) A、B合并，去重
{1,2,3,'a','b',22,33}
'''
res = setA | setB
print(res)  # {1, 2, 3, 'b', 33, 'a', 22}

'''
对称差集
{1,2,3,'a','b'}
^
{1,'a',22,33}
====> (A ^ B) A、B集合不共有的元素
{2,3,'b',22,33}
'''
res = setA ^ setB
print(res)  # {33, 2, 3, 'b', 22}

数据类型转换

复习Python的数据类型有哪些？

'''
字符串 String
数字类型 Number
    整形 Int
    浮点 Float
    复数 Complex
    布尔 Boolean
列表 List
元组 Tuple
字典 Dict
集合 Set
'''

Python数据类型的分类

'''
可变数据类型：列表、字典、集合
不可变数据类型：字符串、数字、元组

容器类型数据：字符串、列表、元组、集合、字典
非容器类型数据：数字、布尔类型
'''

Q ：什么是数据类型转换？
A ：把一个数据类型转换为另一个数据类型，例如字符串转为数字
Q ：为什么需要数据类型转换？
A ：因为不同的数据类型之间不能运算
Q ：数据类型转换的形式？
A ：自动类型转换、强制类型转换

# 自动类型转换
# 当两个不同的值进行运算时，结果会向更高的精度进行计算
# True ==> 整形 ==> 浮点 ==> 复数
a = 123
b = True  # 在和数字运算时 True转为数字1，False转为数字 0
print(a + b)  # 124
print(12.5 + 22)  # 34.5
print(True + 3.14)  # 4.140000000000001

# 强制类型转换
'''
下面的函数，可以把其他类型的数据，转换为对应的数据类型
str() 
int()
float()
bool()
list()
tuple()
dict()
set()
'''

可以把所有的其他数据类型转换为字符串类型
容器类型数据，如果字符串中是纯数字，可以转换
浮点类型的转换和int类型一样
bool可以把其他类型转换布尔类型的True和False

# 正例
varStr = '1234567890'
varInt = int(varStr)
print(varInt)  # 1234567890

# 反例
varStr = '12345a67890'
varInt = int(varStr)
print(varInt)  
# ValueError: invalid literal for int() with base 10: '12345a67890'

总结：哪些情况转bool的结果是 False

'''
   '0'     True
   ' '     False
    0      False
    0.0    False
    False  False
    []     False
    {}     False
    ()     False
    set()  False
'''

容器数据类型转换

1.List列表

字符串转换为列表时，会把字符串中的每一个字符当做列表的元素
数字类型是非容器类型，不能转换为列表list
集合{} 可以转换为 list列表类型
元组() 可以转换为 list列表类型
字典{} 可以转换为 list列表类型，但只保留字典中的键

# str --> list
varStr = 'abcd1fgh2'
varList = list(varStr)
print(varList)
# ['a', 'b', 'c', 'd', '1', 'f', 'g', 'h', '2']

# int !--> list
varInt = 123
varList = list(varInt)
print(varList)
# TypeError: 'int' object is not iterable

# set --> list
varSet = {1,2,3,4,5}
varList = list(varSet)
print(varList)  
# [1, 2, 3, 4, 5]

# tuple --> list
varTuple = (1,2,3,4,5)
varList = list(varTuple)
print(varList)  
# [1, 2, 3, 4, 5]

# dict --> list
varDict = {1:'1',2:'2',3:'3',4:'4',5:'5'}
varList = list(varDict)
print(varList)  
# [1, 2, 3, 4, 5]

2.Tuple元组

字符串转换为元组时，会把字符串中的每一个字符当做元组的元素
数字类型是非容器类型，不能转换为元组
集合{} 可以转换为 Tuple元组类型
元组() 可以转换为 Tuple元组类型
字典{} 可以转换为 Tuple元组类型，但只保留字典中的键

# str --> tuple
varStr = 'abcd1fgh2'
varTuple = tuple(varStr)
print(varTuple)
# ('a', 'b', 'c', 'd', '1', 'f', 'g', 'h', '2')

# int !--> tuple
varInt = 123
varTuple = tuple(varInt)
print(varTuple)
# TypeError: 'int' object is not iterable

# set --> tuple
varSet = {1,2,3,4,5}
varTuple = tuple(varSet)
print(varTuple)
# (1, 2, 3, 4, 5)

# list --> tuple
varTuple = [1, 2, 3, 4, 5]
varTuple = tuple(varTuple)
print(varTuple)
# (1, 2, 3, 4, 5)

# dict --> tuple
varDict = {1:'1',2:'2',3:'3',4:'4',5:'5'}
varTuple = tuple(varDict)
print(varTuple)
# (1, 2, 3, 4, 5)

3.Set集合

数字类型是非容器类型，不能转换为集合
字符串、列表、元组可以转为集合结果时无序的
字典转换为集合时，只保留了字典的键(k)

# str --> set
varStr = 'abcd1fgh2'
varSet = set(varStr)
print(varSet)
# {'d', 'g', '2', 'c', '1', 'h', 'a', 'f', 'b'}

# int !--> set
varInt = 123
varSet = set(varInt)
print(varSet)
# TypeError: 'int' object is not iterable

# tuple --> set
varTuple = {1,2,3,4,5}
varSet = set(varTuple)
print(varSet)
# {1, 2, 3, 4, 5}

# list --> set
varTuple = [1, 2, 3, 4, 5]
varSet = set(varTuple)
print(varSet)
# {1, 2, 3, 4, 5}

# dict --> set
varDict = {1:'1',2:'2',3:'3',4:'4',5:'5'}
varSet = set(varDict)
print(varSet)
# {1, 2, 3, 4, 5}

4.Dict字典

字符串不能直接转换为字典
列表、元组可以转换为字典，但要求是一个二级列表
并且每个二级元素的元素只能有两个元素

# list --> dict
varList = [[1,2],['a','b'],[11,22]]
varDict = dict(varList)
print(varDict)
# {1: 2, 'a': 'b', 11: 22}

# tuple --> dict
varTuple = ((1,2),('a','b'),(11,22))
varDict = dict(varTuple)
print(varDict)
# {1: 2, 'a': 'b', 11: 22}

未完待续。如有错误，请指正

标签：set,入门,22,Python,就够,varTuple,varList,print,元组
来源： https://blog.csdn.net/Li_yangfeng/article/details/110682001

Python入门 看这一篇就够了