python基础复习

时隔一年捡起来,通过Python3 基本数据类型 | 菜鸟教程 (runoob.com)速刷

string

str="Runoob"
print(str)
print(str[0:-1])
print(str[1])
print(str*2)
print(str+"Test")
print(r'Ru\ndad')#不会发生转义前面加上/n

bool

#bool
'''
布尔类型只有两个值:True 和 False。

布尔类型可以和其他数据类型进行比较,比如数字、字符串等。在比较时,Python 会将 True 视为 1,False 视为 0。

布尔类型可以和逻辑运算符一起使用,包括 and、or 和 not。这些运算符可以用来组合多个布尔表达式,生成一个新的布尔值。

布尔类型也可以被转换成其他数据类型,比如整数、浮点数和字符串。在转换时,True 会被转换成 1,False 会被转换成 0。
'''
a=True
b=False
\#比较
print(2<3)
\#逻辑
print(a and b)
print(a or b)
print(not a)
\#类型转换
print(int(a))
print(float(b))#括起来哦
print(str(a))#bool-》string

注意: 在 Python 中,所有非零的数字和非空的字符串、列表、元组等数据类型都被视为 True,只有 0、空字符串、空列表、空元组等被视为 False。因此,在进行布尔类型转换时,需要注意数据类型的真假性。

List

List(列表) 是 Python 中使用最频繁的数据类型。

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

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

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

变量[头下标:尾下标]
#List
list=['adad','dadad',2.33,'dasda']
tinyList=[1312,'2312312']

print(list)
print(list[0])
print(list[1:3])
print(list[2:])
print(tinyList*2)#*重复操作
print(list+tinyList)#+为连接操作

a=[0,45,5,2,52,2]
a[0]=99
print(a)
a[2:4]=[]#去掉5和2
print(a)
#翻转字符串演示
def reverseWords(input):
    inputWord=input.split(" ")
    inputWord=inputWord[-1::-1]
    output=' '.join(inputWord)
    return output
if __name__=='__main__':
    input='hello world'
    rw=reverseWords(input)
    print(rw)


元组

元组(tuple)与列表类似,不同之处在于元组的元素不能修改。元组写在小括号 () 里,元素之间用逗号隔开。

元组中的元素类型也可以不相同:

tuple=('abcd',786,'runoob')
tinyTuble=(123,'runoob')

print(tuple)
print(tuple[0])
print(tuple[1:3])
print(tuple[2:])
print(tinyTuble*2)
print(tuple+tinyTuble)

\#tuple[1]=0 无法修改元组中的元素

set

集合(set)是由一个或数个形态各异的大小整体组成的,构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。

parame = {value01,value02,...}
或者
set(value)
myset={'dasda','hello','baidu'}
print(myset)

if 'hello' in myset:
    print("在集合中")
else:
    print("不在集合中")

a=set('abbcasca')
b=set('alacazam')

print(a)
print(a-b)
print(a|b)#并集
print(a&b)
print(a^b)

字典

字典(dictionary)是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。

字典是一种映射类型,字典用 { } 标识,它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中,键(key)必须是唯一的。

odict={}
odict['one']="1-真的离谱"
odict[2]="2-芜湖"

tinydict={'name':'符传朔','nani':'dasda'}

print(tinydict)
print(odict)
print(odict[2])
print(tinydict.keys())
print(tinydict.values())
#构造函数 dict() 可以直接从键值对序列中构建字典如下:
mydict=dict([('runnov',1),('da',2),('taibap',3)])
print(mydict)
mydict.clear();
print(mydict)

注意:

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

bytes类型

x=bytes("hello",encoding="utf-8")
print(x)
y=b"hello"
print(y)
z=x[1:3]
print(z)
z=x+b"worf"
print(z)
x=b"hello"
if x[0]==ord("h"):
    print("same")
else:
    print("different")

f-string

f-string 是 python3.6 之后版本添加的,称之为字面量格式化字符串,是新的格式化字符串的语法。

之前我们习惯用百分号 (%):

name='runoob'
s='hello%s'%name
print(s)

f-string 格式化字符串以 f 开头,后面跟着字符串,字符串中的表达式用大括号 {} 包起来,它会将变量或表达式计算后的值替换进去,实例如下:

w={'name':'runoob','url':'www.runoob.com'}
k=f'{w["name"]}:{w["url"]}'
print(k)

条件控制语句

if

Python中if语句的一般形式如下所示:

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

Python 中用 elif 代替了 else if,所以if语句的关键字为:if – elif – else

number=7
guess=-1
print("猜数字游戏开始")
while guess!=number:
    guess=int(input("请输入你猜的数字:"))

    if guess==number:
        print("恭喜,你猜对了!")
    elif guess<number:
        print("猜的数字小了。。。")
    elif guess>number:
        print("猜的数字大了。。。")
        

Match…case

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "not Found"
        case 418:
            return "i'm a teapot"
        case _:
            return "someThing wrong with internet"

my_status = 400
print(http_error(400))

python推导式

列表推导式

列表推导式格式为:

[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]

或者 

[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]
  • out_exp_res:列表生成元素表达式,可以是有返回值的函数。
  • for out_exp in input_list:迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
  • if condition:条件语句,可以过滤列表中不符合条件的值。
#1.列表推导式
name=['bob','tom','peter']
newnames=[name.upper() for name in name if
          len(name)>3]
print(newnames)

字典推导式

字典推导基本格式:

{ key_expr: value_expr for value in collection }

或

{ key_expr: value_expr for value in collection if condition }

使用字符串及其长度创建字典:

#2.字典推导式
listdemo=['Google','taobao']
newdict={key:len(key) for key in listdemo}
print(newdict)

元组推导式

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型,快速生成一个满足指定需求的元组。

元组推导式基本格式:

(expression for item in Sequence )
或
(expression for item in Sequence if conditional )

元组推导式和列表推导式的用法也完全相同,只是元组推导式是用 () 圆括号将各部分括起来,而列表推导式用的是中括号 [],另外元组推导式返回的结果是一个生成器对象。

例如,我们可以使用下面的代码生成一个包含数字 1~9 的元组:

#python推导式
#元组推导式
a=(x for x in range(1,10))
print(tuple(a))

迭代器

list=[1,2,3,4]
it=iter(list)
for x in it:
    print(x,end=" ")
import sys

list=[1,2,3,4]
it=iter(list)

while True:
    try:
        print(next(it))
    except StopIteration:
        sys.exit()


'''
__iter__() 方法返回一个特殊的迭代器对象, 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。

__next__() 方法(Python 2 里是 next())会返回下一个迭代器对象。

创建一个返回数字的迭代器,初始值为 1,逐步递增 1:
'''
class MyNum:
    def __iter__(self):
        self.a=1
        return self
    def __next__(self):
        x=self.a
        self.a+=1
        return x

myclass=MyNum()
myiter=iter(myclass)

print(next(myiter))
class MyNum:
    def __iter__(self):
        self.a=1
        return self
    def __next__(self):
        if self.a<=20:
            x=self.a
            self.a+=1
            return x
        else:
            raise StopIteration
myclass=MyNum()
myiter=iter(myclass)

for x in myiter:
    print(x)

传递参数

def change(a):
    print(id(a))
    a=10
    print(id(a))

a=1
print(id(a))
change(a)

不可变

def changeme(list):
    list.append([1,2,3,4])
    print("函数内取值",list)
    return

mylist=[10,290]
changeme(mylist)
print("函数外取值:",mylist)

可变

面向对象

class Student:
    def __init__(self,name,score):#构造函数
            self.name=name;
            self.score=score;
    def say_score(self):
            print("{0}的分数是{1}".format(self.name,self.score));

s1=Student("zhangsan",11)
print(s1.name,s1.score)
s1.say_score();

默认函数

#默认参数
def printInfo(name,age=37):
    print("名字",name)
    print("年龄",age)
    return

printInfo(age=31,name="fcs")
print("------------------")
printInfo(name="rub")

不定长函数

#不定长参数
def printinfo(arg1,*var):
    print("输出:")
    print(arg1)
    print(var)

print(70,8,5)
def printinfo(arg1,**vartuple):
    #双*号就是为字典
    print("输出:")
    print(arg1)
    print(vartuple)

printinfo(1, a=2,b=3)

Lambda

x= lambda a:a+10
print(x(5))

sum=lambda arg1,arg2:arg1+arg2

print(sum(10,20))
print(sum(20,20))

def myfunc(n):
    return lambda a:a*n
mydoubler=myfunc(2)
print(mydoubler(11))

你可能感兴趣的:(机器学习,python,开发语言,数据分析)