python3基础学习一-优快云博客

本文链接：https://blog.youkuaiyun.com/hjc_042043/article/details/135965121

python3基础学习

打印print()函数

R 主要的原因是为防止转义，保证r后面的内容全文输出
f “主要作用就是格式化字符串，加上f以后，{“变量/表达式”},花括号里的变量和表达式就可以使用了”

def ptSubstr():
    msg = "hello,world!"
    print(msg[0:-1]);
    print(msg[2:5]) #打印从第3个字符到第5个字符
    print("\n")   #打印空行
    print(msg[2:])  #打印从第3个字符开始后的所有字符
    print(r"-----\n") #字符串前面加r表示字符串不转义
    print(f"倒数第三个字符：{msg[-3:]}") #打印倒数3个字符

数据类型

在python中，每个数据类型都可以当做是对象，当赋值时，对象就被创建了

数据类型	名称	备注说明	容量是否可变
Number	数字	int包含长整型,float,bool,complex(复数)	否
String	字符串	底层结构：序列	否
Tupe	元组	底层结构：序列	否
List	列表	底层结构：序列	是
Set	集合	是一个无序的不重复的无序元素序列	是
Dictionary	字典	类似于JSON串，由key:value组成	是

Number（数字）

python3支持int、float、bool、complex（f复数），它们都属于数字类型
在python3中，只有一种整型类型int，表示为长整型,没有python2中的long类型
内置的type()函数可以用来查询变量所指的对象类型
python3中，bool是int的子类，True和False可以和数字相加，True1、False0 会返回True，但可以通过is来判断类型

"""
Number类型
"""

def ptNumberType():
    a,b,c,d = type(20),type(5.5),type(True),type(4+3j)  #在赋值时，Number对象就会被创建
    print(a,b,c,d)  # 通过打印，这些类型都是对象类型
    print(isinstance(20,int));   #打印对象a是否是int类型

#打印数据类型
ptNumberType()


def ptBool():
    res = issubclass(bool,int)  # bool类型是否是int的子类
    print(res)

    valEQ1 = (True ==1)
    print('valeq1：',valEQ1)    # True和1是否值相等

    valEQ2 = (False == 0)
    print("valeq2：",valEQ2)   # False和0是否值相等

    typeEQ1 = (1 is True)
    print("typeEQ1：",typeEQ1)  # 1和True的类型是否相等，is是来判断类型
    typeEQ2 = (0 is False)
    print("typeEQ2：",typeEQ2)  # 0和False的类型是否相等

    print(True + 1)     # bool类型和int类型值相加

# 打印布尔类型的特性
ptBool()

销毁对象

def delObj():
    var1,var2 = 1,10    #赋值，创建对象
    print(var1,var2)

    del var1,var2   #删除对象
#print(var1,var2) #报错，因为对象var1,var2已经被删除了

# 删除对象
delObj()

数值运算

def oprations():
    print('求和：', 1+2)
    print('减法：', 10.8-5)
    print('乘法：', 5*10)
    print('除法-浮点型：', 12/8)  # 除法，得到一个浮点数
    print('除法-整型：', 12//8)  # 除法，得到整型
    print('求余：', 12 % 7)  # 求余
    print('乘方：', 2**3)  # 2的3次方


# 数值运算
oprations()

注意

1.python可以同时为多个变量赋值
2 .一个变量可以通过赋值指向不同类型的对象
3.数值的除法，包含两个运算符："/“返回浮点数，”//"返回整数
4.在混合计算时，python会把整型转换成浮点型

String(字符串)

python中的字符串用单引号和双引号括起来，同时使用反斜杠""转义特殊字符

字符串的截取的语法格式如下：

start下标表示从start开始截取，到end下标的前一个元素结束，注意不包含end下标
索引值以0为开始值，-1为从末尾的开始位置

str[start下标:end下标]

下标，从0开始为顺序的开始位置，从-1开始为逆序的开始位置

字符串截取

# 字符串截取测试
def ptStr():
    str = "Runoob"

    print('所有字符：', str[::])   #输出所有字符串
    print('第1个字符：', str[0])   #输出字符串的第一个字符
    print('输出到第2个字符：', str[:2]) #输出字符串从0开始到第2个字符
    print('输出到第3个字符到结尾：',str[2:])    #输出从第三个开始后的所有字符
    print('第1个到倒数第2个的所有字符：',str[0:-1]) #输出第一个到倒数第二个的所有字符
    print('输出两次字符串：',2 * str)
    print('连接字符串：',str+'Test')    #连接字符串
    print(f"key={key},value={val}")   #格式化字符串，防止变量被转义

ptStr()

字符赋值测试

在python中，没有字符类型，只有字符串类型，并且字符不能被赋值；比如word[0]=‘P’,会导致错误

def assgin():
    word = "python"
    print(word[0],word[5])  #打印第一个，第六个字符

    word[0] = 'P'           #字符串的容量是不可变的，在赋值时会报错
    print(word[-1],word[-6])    #打印倒数第一个，倒数第六个字符

# 字符赋值测试
assgin()

注意

反斜杠可以用来转义，字符串前面使用了r，就不会进行转义
字符串可以用+运算符连接在一起，用*运算符重复。
python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
python中的字符串不能改变

List（列表）

List是python中使用最频繁的数据类型。
列表中的元素可以不相同，它支持数字，字符串甚至是列表，集合等
列表的格式使用[]，里面的元素使用,隔开的元素列表
和字符串一样，列表可以被索引和截取，列表被截取后返回一个包含所需元素的新列表

列表被截取的语法格式：

start下标表示从第start个开始截取，end表示到第end个元素结束，即下标end前一个元素结束，注意不包含end下标
索引值以0为开始值，-1为从末尾的结束位置
索引值不管是正还是负，都是从左到右开始计数

变量[start下标:end下标]

简单实例

list = [1,"hjc","email",3.14,True]
list2 = [2,"username"]

print(list)    #打印list列表
print('list的第1个元素:',list[0])   #打印第1个元素
print('list下标为1开始,到第3个元素结束:',list[1:3]) #打印下标从1开始，到第3个元素结束
print('list下标为2开始到结束的所有元素:',list[2:])   #打印下标从2开始的所有元素
print('list2输出两次:',list2 *2 )  #打印两次list2
print('将list+list2两个列表合并:',list+list2)

注意：

list中的元素是可以被改变的。
list可以使用"+"操作符可以进行拼接的
python列表截取可以接收第三个参数，参数的作用是截取的步长，以下实例在索引1到4的位置设置步长为2，来截取字符串，如果第三个参数为负数，表示来翻转字符串用：

#打印list列表,测试分片，列表的合并
def testList():
    list = [1, "hjc", "email", 3.14, True]
    list2 = [2, "username"]

    print(list)  #打印list列表
    print('list的第1个元素:', list[0])  #打印第1个元素
    print('list下标为1开始,到第3个元素结束:', list[1:3])  #打印下标从1开始，到第3个元素结束
    print('list下标为2开始到结束的所有元素:', list[2:])  #打印下标从2开始的所有元素
    print('list2输出两次:', list2 * 2)  #打印两次list2
    print('将list+list2两个列表合并:', list + list2)

# testList()


#测试列表元素的改变，
def testList2():
    list = ['a', 'b', 'c', 1, 2, 3]
    list[0] = 9
    print('第1个元素被改变：', list)

    list[:3] = [4, 5, 6]
    print('从第1个元素到第3个元素被改变：', list)

    list[2:5] = [3, 6, 9]
    print('从第3个元素到第5个元素被改变：', list)

    list[-2:] = []
    print('从倒数第2个元素开始，设置为空：', list)

testList2()

#测试步长取值
def testStep():
    list = [1,2,3,4,5,6]
    newList = list[0::2]
    print('从0开始到末尾,取值步长为2，即隔2个取一次：',newList)

    newList2 = list[-1::-1]
    print('从下标最后一个元素开始到末尾,取值步长为-1，即隔反向取一次：',newList2)

testStep()

#步长为负数，来做字符串反转
def reverseWords(str):
    inputWords = str.split(',') #分割字符串，放到列表中
    inputWords = inputWords[-1::-1]

    output = ','.join(inputWords)   #重新拼接到字符串
    print(output)

reverseWords('a,b,c,d,e,f')




#将字符串的字符塞入到列表中
def strPushList(str):
    list = []
    for item in str:
        list.append(item)

    return list


lastList = strPushList("hjc_042043@sian.cn")
print(lastList)

Tuple（元组）

元组(tuple)和列表相似，不同之处在于元组的元素不能被改变，元组是在"()“里，元素之间用”,"隔开
元组中的元素类型也可以不相同
元组和列表都可以视为数组，只是列表是类型可以改变，可以自由伸缩，可以用作队列来使用。元组是长度不可变的，可以用在枚举，配置等。

实例说明：

# 测试元组的赋值，取值
def testTuple():
    tuple = (1, 2, 3, 4, 5, 6)
    tuple2 = ('abc', 'hjc')

    print('打印tuple的所有元素：', tuple)
    print('打印tuple的第一个元素：', tuple[0])
    print('打印tuple的第二个元素到第三个元素：', tuple[1:3])
    print('打印从第三个元素开始的所有元素：', tuple[2:])
    print('将tuple2的元素打印两次：', tuple2 * 2)
    print('将tuple2和tuple进行合并：', tuple + tuple2)

    tuple2[0] = '123'
    print('不能修改元组：', tuple2)

#testTuple()

# 测试元组的声明
def declraTuple():
    tup1 = ()
    tup2 = (1)  #如果是一个元素，元素后面需要加,
    print(tup1,tup2)

declraTuple()

集合(set)

集合是有一个或者N个整体构成，可以是不同的数据类型，构成集合的事物被称作是元素或成员
基本功能是成员关系测试(判断元素是否在集合中)和删除重复元素
可以使用set()函数创建集合，注意创建一个空集合必须使用set()，因为"{}"是创建一个空字典
如果不要求是顺序的，可以用集合来代替列表，在性能上集合比列表要快。

创建格式：

value = {val1,val2,val3...}
或者
value = set(val1)

实例说明：

#集合声明，成员测试
def testSet():
    set1 = set()
    print('空集合初始化：', set1)

    set2 = {'taobao', 'jingdong', 'pingduoduo', 'facebook', 'baidu', 'taobao'}
    print('输出集合，集合自动排序，重复的元素自动去掉：', set2)

    #成员测试
    if 'taobao' in set2:
        print('taobao在集合set2中')
    else:
        print('taobao不在集合set2中')


testSet()

def create_set():
    """
    创建集合
    :return:
    """
    set1 = {1, 2, 3, 3, 4, 5}
    print("set1=", set1)
    print("set1_len=", len(set1))

    # 使用构造器语法创建集合
    set2 = set("hello")
    print("set2=", set2)

    # 将列表转换成集合,并去掉重复元素
    set3 = set([1, 2, 3, 3, 2, 1, 5])
    print("set3=", set3)

    # 使用生成器
    set4 = {num for num in range(1, 20) if num % 3 == 0 or num % 5 == 0}
    print("set4=", set4)


create_set()

'''
集合运算
set1: 集合1
set2: 集合2
op: 操作符
'''

#集合的运算
def testSet2(set1, set2, op):
    lastSet = set()

    if op == '+':
        #lastSet=set1+set2   #集合合并,这是错误的，正确用法使用'|'
        lastSet = {"集合合并,这是错误的，正确用法使用'|'"}
    elif op == '-':
        lastSet = set1 - set2  #集合的差集
    elif op == '|':
        lastSet = set1 | set2  #集合的并集
    elif op == '&':
        lastSet = set1 & set1  #集合的交集
    elif op == '^':
        lastSet = set1 ^ set2  #集合中不同时存在的元素
    else:
        lastSet = {"unknown"}  #操作符不正确

    return lastSet


set1 = {1, 2, 3, 4, 5, 6}
set2 = {1, 3, 5, 7, 9, 11}

print('集合合并：', testSet2(set1, set2, '+'))
print('集合差集：', testSet2(set1, set2, '-'))
print('集合合并：', testSet2(set1, set2, '|'))
print('集合交集：', testSet2(set1, set2, '&'))
print('集合的异或操作：', testSet2(set1, set2, '^'))

集合运算示例2

def op_set():
    """
    集合运算
    :return:
    """

    # 成员运算
    set1 = {1, 2, 3, 4, 5}
    print("6 is in=", 6 in set1)
    print("5 is in=", 5 in set1)
    set2 = {"Python", "Java", "Go", "Php"}
    print("Python is in=", "Python" in set2)
    print("C++ is in=", "C++" in set2)

    # 交并差运算,和数学上的交并差一样
    set1 = {1, 2, 3, 4, 5, 6, 7, 8}
    set2 = {2, 4, 6, 8, 10}

    # 求交集
    res = set1 & set2
    print("两集合交集：", res)
    print("两集合交集第二种方法：", set1.intersection(set2))
    # 求并集
    res = set1 | set2
    print("两集合并集：", res)
    print("两集合并集第二种方法：", set1.union(set2))
    # 求差集
    res = set1 - set2
    print("两集合差集：", res)
    print("两集合差集第二种方法：", set1.difference(set2))
    # 对称差,相当于是两集合的并集-两集合的交集,使用异或符号
    res = set1 ^ set2
    print("两集合的对称差：", res)
    print("两集合的对称差第二种方法：", set1.symmetric_difference(set2))
    print("两集合的对称差第三种方法：", (set1 | set2) - (set1 & set2))

op_set()

集合函数

add：添加一个元素
update：添加一个或一组元素，可以是字符串，集合，列表，元祖元素
discard：删除一个元素，如果元素不在集合中，不会报错
remove：同样也是一个元素，如果不在集合中，就会报错
clear：清空集合
isdisjoint：判断两个集合是否存在交集，不存在返回False，存在就返回True

def method_set():
    """
    集合的方法
    :return:
    """

    # 创建一个空集合
    set1 = set()

    # 通过add方法添加元素
    set1.add(1)
    set1.add(2)
    # 添加多个元素
    set1.update(set1, {3, 4, 5, 6, 7})
    print("set1-add=", set1)

    # 通过discard方法删除指定元素
    set1.discard(7)
    set1.discard(8)
    print("set1-update=", set1)

    # 通过remove方法删除元素,建议先做成员运算在删除
    # 如果key不存在，就会引发KeyError异常
    if 10 in set1:
        set1.remove(10)
    print("set1-remove=", set1)

    # pop方法可以从集合中随机删除一个元素，并返回一个元素
    pop_item = set1.pop()
    print("set1-pop=", pop_item)

    # clear方法可以清空整个集合
    set1.clear()
    print("set1-clear=", set1)

    # 判断两个集合有没有相同元素(交集),使用isdisjoint方法，没有相同元素返回true,否则返回false
    set1 = {"Java", "C++", "Python", "Golang"}
    set2 = {"Swift", "C", "Golang"}
    set3 = {"Html", "Javascript", "Css"}
    print("set1和set2是否有相同的元素", set1.isdisjoint(set2))
    print("set1和set3是否有相同的元素", set1.isdisjoint(set3))

字典(Dictionary)

列表是有序的对象集合，字典是无序的对象集合，两者之间的区别在于：字典当中元素通过键来进行存取，而不是通过偏移量来进行存取
字典是一种映射关系，使用{key:value}来进行标识，他是一个无序的的集合
key必须是不可变类型，一般是字符串来表示，并且同一个字典中键是唯一的

# 测试字典的特性
def testDic1():
    '''
    字典声明的第一种方式
    '''
    dic = {}
    dic[0] = 'test'
    dic['uid'] = '1234089'
    dic['user_name'] = 'hjc_042043'
    dic['email'] = 'hjc_042043@sian.cn'
    dic['phone'] = '13634199417'

    print('输出key=uid的值：', dic['uid'])
    #print('输出key=2的值：',dic[2])     #注意字典类型是不能隐式转换成list类型的，这里因为key中没有2的元素，所以会报错

    print('输出完整的字典dic：', dic)

    print('输出所有的键名：', dic.keys())
    print('输出所有的值：', dic.values())

# testDic1()


# 测试字典2
def testDic2():
    dic = dict([('real_name', '黄锦潮'), ('age', 37), ('sex', 1)])
    print('字典声明的第2种方式：', dic)

    dic2 = dict(real_name='黄锦潮', sex=1, age=37)
    print('字典声明的第3种方式：', dic2)

    dic3 = {'order_sn': '009780832378', 'address': '杭州市西湖区文一西路'}
    print('字典声明的第4种方式：', dic3)

    # 推导式
    dic4 = {x: x**2 for x in (2, 3, 4)}
    print('字典推导式的使用：', dic4)


testDic2()

Python数据类型转换列表

有时候，我们需要对数据内置的类型进行转换，只需要对数据类型作为函数名进行转换即可
以下几个内置数据类型之间进行转换，这些函数返回一个新的对象，表示转换的值

函数	描述
int(x)	将x转换成一个整数
float(x)	将x转换成一个浮点数
complex(x)	创建一个复数
str(x)	将对象转换成字符串
repr(x)	将对象x转换成表达式字符串
eval(x)	用来计算字符串中有效的python表达式，并返回一个对象
tuple(s)	将序列转换成元组类型
list(s)	将序列转换成列表类型
set(s)	转换成可变集合
dict(d)	创建一个字典，d必须是一个(key,value)元组序列
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换成一个字符
ord(x)	将一个整数转换成8进制
oct(x)	将一个整数转换成16进制

数据类型转换

有时候，我们需要对数据类型的转换，包括内置的数据类型，一般情况下只需要将数据类型作为函数即可
Python 数据类型转换可以分为两种：

隐式转换–自动完成
显示类型转换—需要使用类型函数转换

隐式转换

在隐式转换中，python会自动转换为另一种数据类型，不需要我们去干预
在以下实例中，我们对两种不同类型的数据进行运算，较低数据类型（整数）就会转换成较高数据类型（浮点数）以避免数据丢失

# 测试将整型隐式转换成浮点型
from xml.dom.minidom import TypeInfo


def testParse():
    numInt = 10
    numFloat = 10.5
    '''
    因为int类型的优先级比float要底，所以计算时会自动转换成浮点数，不然精度容易溢出
    数据类型的优先级：byte,char-->int--->long--->float--->double
    不能将对象转换成不相关类的对象类型
    把容量大的类型转换成容量小的类型时，必须使用强制类型转换
    浮点数到整数，是通过舍弃小叔得到，而不是四舍五入
    '''
    numNew = numInt + numFloat

    print('整数和浮点数相加：', numNew)


#testParse()


# 隐式转换
def strToInt():
    numInt = 10
    numStr = "122"
    numBool = True

    print('data type of numInt：', type(numInt))
    print('data type of numStr：', type(numStr))
    print('data type of numBool：', type(numBool))

    print('int + boolen：', numInt + numBool)

    numNew = numInt + numStr  #这样子会报错，因为字符串类型不是数字类型，需要进行显示转换。
    print("numNew is ", numNew)


# strToInt()

显式转换

# 显示转换
def testParse2(num1, num2):
    return num1 + num2


# int类型相加
intSum = testParse2(1, int('123'))
print('int类型求和：', intSum)

# float类型相加
floatSum = testParse2(float(2), 3.14)
print('float类型求和', floatSum)

# str类型相加,是字符串拼接
strNew = testParse2(str(2),str(3.14))
print('str类型相加',strNew)

推导式

python推导式是一种特殊数据处理方式，可以从一个数据序列构件另一个数据序列的结构体
python支持各种数据结构的推导式：

列表(list)推导式
字典(dict)推导式
集合(set)推导式
元组(tuple)推导式

列表推导式

列表推导式，注意，这里的表达式没有冒号，其执行顺序：从左到右依次递进,语句之间是嵌套关系

格式：

[表达式表示最终需要得到的结果 for 变量 in iterable(可迭代对象)]
[out_exp_res for variable in input_list]

或

[表达式表示最终需要得到的结果 for 变量 in iterable(可迭代对象) if 条件]
[out_exp_res for variable in input_list condition]

代码示例1：

不带条件

 # 取范围的整数进行遍历，将遍历出来的结果*10再加入列表中
 # lst2 = []
 # for x in range(1,10):
 #     lst2.append(x*10)
 lst2 = [x*10 for x in range(1,10)]
 print(lst2)

 # 取范围的整数进行遍历，将遍历出来的的结果平方再加入列表
 # lst3 = []
 # for x in range(1,10):
 #     lst3.append(x*x)
 lst3 = [x*x for x in range(1,10)]
 print(lst3)

代码示例2

带条件的

"""
求整数1-9的偶数
取范围1-9的整数进行遍历，遍历时判断求余==0的数值加入列表
lst1 = []
for x in range(1,10):
    if x % 2 == 0:
        lstData.append(x+1)
"""
lst1 = [x for x in range(1,10) if x % 2 == 0]
print(lst1)

字典推导式

字典推导式和列表推导式类似，只不过中括号改成大括号而已，区别就是字典推导式返回的类型是字典

格式：

格式1：{key:value for value in iterable(可迭代对象)}

格式2：{key:value for value in iterable(可迭代对象) if 条件}

代码示例1：

不带条件

lst = ['hello', 'python', 'java']
# 还原字典推导式的实现
# new_dict = {}
# for x in lst:
#     new_dict[x] = len(x)
# print(new_dict)

dic = {x: len(x) for x in lst}
print(dic)

代码示例2：

带条件

"""
利用推导式计算一组股票价格大于100元的值
:return:
"""
d = {
    "601800": 10.74,
    "300776": 62.98,
    "300576": 44.10,
    "002594": 260.5,
    "300750": 223.47,
    "600519": 1711.05,
}
# 还原字典推导式
# new_dict = {}
# for key,val in d.items():
#     if val > 100:
#       new_dict[key] = val
    
new_dict = {key: val for key, val in d.items() if val > 100}
print("new_dict=", new_dict)