python基础知识1

最新推荐文章于 2022-11-24 12:30:16 发布

画辆宝马开

最新推荐文章于 2022-11-24 12:30:16 发布

阅读量165

点赞数

分类专栏： Python

本文链接：https://blog.csdn.net/kira_shen/article/details/83863736

版权

Python 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

变量

变量包括了：变量的标识、名称、数据；变量名称相同，该变量不一定相同，因为标识不同
变量不需要声明，直接赋值，赋值即完成了声明和定义
所以在使用变量前，必须先赋值，否则该变量不存在
函数内部的为局部变量，可以用global引申为全局变量

#变量名称相同，该变量不一定相同，因为标识不同
x = 1
print(id(x))
x = 2
print(id(x))
#所以在使用变量前，必须先赋值
#print(y)
def fun():
    global a
    a=10
    print(a)
fun()
print(a+x)

#############
4484900192
4484900224
0
2

数据类型

python根据变量的值自动判别类型
python自动为该变量的生命周期负责
因此所有类型均是python对象
通过内置函数type()查看变量的类型
类型包括：数字、None、字符串、列表、集合、元组、字典

数字

根据变量值自动转化
None表示什么都没有

# 数字
x=1
print(type(x))
x=1.1
print(type(x))
x=1111111111
print(type(x))
x=1-2j
print(type(x))
x=False
print(type(x))
x=None
print(type(x))
##############
<class 'int'>
<class 'float'>
<class 'int'>
<class 'complex'>
<class 'bool'>
<class 'NoneType'>

字符串

使用’ ‘," ",’’’ ‘’’,表示
连接操作+、重复操作*、切片操作[]
help(str)查看字符串内置函数

a = "hello"
b = "  world"
c = ",i'm shen."
print(a+b+c)
print(a*2)
print(c[5:9])

#help(str)
###################
hello  world,i'm shen.
hellohello
shen

列表-list

一系列元素包含在[]中，数据可以是任意类
list可以增删改查
list是有序列表，从0开始访问
一些操作：索引，分片，序列相加，相乘，成员资格操作等

#创建使用[]
l = [1,2,"apple","banana"]
print(type(l))
print(l)

#索引使用[]
l = [[1,2,3],["apple","banana"],False,(1,2,3),"people"]
print(l[0][1])
print(l[1][1])

#切片使用[n:m]
print(l[1:3])

#增加
#在末尾增加
l.append(["cat","dog"])
print(l)
#在指定位置增加，insert(index,object)
l.insert(3,["hello","world"])
print(l)

#删除
#删除指定的值，remove(value)
#先判断该数据是否在此list中
if False in l:
    l.remove(False)
#删除索引值，如果不指定则删除最后一个，pop([index])
l.pop(2)
print(l)

#修改
l[0]="3"
print(l)

#查找 
#index(value[,start[,end]]) 存在返回索引 不存在报错
#in 存在True 不存在False
print(l.index("people"))
print(False in l)

#排序,仅对单类型的排序
ll = ["a","j","c"]
ll.sort()
print(ll)
#反转
ll.reverse()
print(ll)

#help(list)
###################
<class 'list'>
[1, 2, 'apple', 'banana']
2
banana
[['apple', 'banana'], False]
[[1, 2, 3], ['apple', 'banana'], False, (1, 2, 3), 'people', ['cat', 'dog']]
[[1, 2, 3], ['apple', 'banana'], False, ['hello', 'world'], (1, 2, 3), 'people', ['cat', 'dog']]
[[1, 2, 3], ['apple', 'banana'], (1, 2, 3), 'people', ['cat', 'dog']]
['3', ['apple', 'banana'], (1, 2, 3), 'people', ['cat', 'dog']]
3
False
['a', 'c', 'j']
['j', 'c', 'a']

#python完全可以用list实现堆栈、队列，比C/java方便
#堆栈，先进后出，插入元素指针指向新元素，弹出元素指针指向下一个元素
#队列，先进先出，首尾指针，插入元素尾指针指向新元素，弹出元素首指针指向第二个元素

#实现堆栈
stack = [1,2,3,4,5,6]
stack.append(7)#push
print(stack)
value = stack.pop()#pop
print("pop:",value)
print(stack)

#实现队列
queue = ['a','b','c','d','e']
queue.append('f')#push
print(queue)
value = queue.pop(0)#pop
print("pop:",value)
print(queue)
################
[1, 2, 3, 4, 5, 6, 7]
pop: 7
[1, 2, 3, 4, 5, 6]
['a', 'b', 'c', 'd', 'e', 'f']
pop: a
['b', 'c', 'd', 'e', 'f']

元组-tuple

一系列元素包含在()中，数据可以是任意类
写保护：一旦定义则无法修改，所以长度也固定了
元组是有序列表，从0开始访问
一些操作：索引，分片，序列相加，相乘，成员资格操作等

#创建使用()
#tuple单元素定义时，加逗号，因为单元素时，python无法区分()是表达式还是tuple"
t = ("apple")
print(t[0])
print(type(t))
t = ("apple",)
print(t[0])
print(type(t))

#不能修改
#t[0]="banana"

#索引使用[]
t = (("apple","banana"),("cat","dog"),"people",[2,2,1])
print(t[0][1])
print(t[3][2])

#切片使用[n:m]
print(t[1:3])

#遍历，长度len()，遍历range(), 成员访问
for i in range(len(t)):
    print("tuple{0}:".format(i))
#     for j in range(len(t[i])):
#         print(t[i][j])
    for j in t[i]:
        print(j) 

#help
#help(tuple)
################
a
<class 'str'>
apple
<class 'tuple'>
banana
1
(('cat', 'dog'), 'people')
tuple0:
apple
banana
tuple1:
cat
dog
tuple2:
p
e
o
p
l
e
tuple3:
2
2
1

字典-dict

数据以“键-值”形式出现，包含在{}中
字典中的数据每个都有“键-值”对组成，
- key: 必须是可哈希的值，比如int,string,float,tuple, 但是，list,set,dict 不行
- value: 任何值
字典是序列类型，但是是无序序列，所以没有分片和索引
字典可以增删改查，访问通过key

#dict创建
d = {"a":1,"b":2,"c":3,"d":4}
#访问
#使用key访问
print(d["c"])
#使用get()访问，存在返回值，否则返回None
print(d.get("g"))
#修改
d["c"] = 0
print(d)
#增加
d["e"] = 5
print(d)
#删除
del(d["e"])
d.pop("b")
print(d)
#清除
#d.clear()

#遍历
# for 
for k in d:
    print("{0}:{1}".format(k,d[k]))
# items(),items()把每一对“键-值”组成一个元组
for (k,v) in d.items():
    print("{0}:{1}".format(k,v))

#操作
#keys()返回字典的键list
#values()返回字典值list
print(d.keys())
print(d.values())

#更新
#update，将某字典更新到原字典
dd = {'t':True,'f':"False"}
d.update(dd)
print(d)
###############
3
None
{'a': 1, 'b': 2, 'c': 0, 'd': 4}
{'a': 1, 'b': 2, 'c': 0, 'd': 4, 'e': 5}
{'a': 1, 'c': 0, 'd': 4}
a:1
c:0
d:4
a:1
c:0
d:4
dict_keys(['a', 'c', 'd'])
dict_values([1, 0, 4])
{'a': 1, 'c': 0, 'd': 4, 't': True, 'f': 'False'}

集合-set

集合和数学中的概念差不多,创建使用{}
一堆确定的无序的唯一的数据，集合中每一个数据成为一个元素
集合内数据无序，即无法使用索引和分片
集合内部数据元素具有唯一性，可以用来排除重复数据
集合内的数据，str, int, float, tuple等，不可以是list

#创建
s = {1,2,3,4}
print(type(s))
#如果是空的，则默认为字典
s = {}
print(type(s))

# 集合在赋值后自动过滤掉重复元素
s = {23,223,545,3,1,2,3,4,3,2,3,1,2,4,3}
print(s)

#集合内置函数
# help(set)
# intersection: 交集
# difference:差集
# union: 并集
# issubset: 检查一个集合是否为另一个子集
# issuperset: 检查一个集合是否为另一个超集

############
<class 'set'>
<class 'dict'>
{545, 1, 3, 2, 4, 23, 223}

运算符

算数运算符

没有++ --运算
+、 -、 *、 /
// 整除
% 取余
** 次幂
优先级：先*/ 后±

比较运算符

等于==
不等于!=
大于>
小于<
不小于>=
不大于<=
优先级：< <= > >=优先级相等，且高于==、！=
比较运算优先级低于算数运算

逻辑运算符

and
or
not
运算规则：按照顺序从左到右运算，一旦确定未来的值不再计算，直接返回
优先级：and和or相等，且低于not
逻辑运算优先级低于比较运算

赋值运算符

=
+= -= *= /= //= **=

位运算符

把数字看出二进制进行按位计算
位或|
位与&
位异或^
位非~
左移<<
右移>>

身份运算符

name id value
判断两个变量是否为同一个变量，不意味着值相同，但值相同也未必同一个
is和==区别：is判断两个变量的引用对象是否为同一个,==是判断引用变量的值是否相等
is
not is

成员运算符

判断某个变量是否是另一个变量的成员,结果为布尔值
in
not in

程序结构

if

注意是eiif，不是elseif
elif 可以由很多个
多路分支只会选一个执行
可以只有if

     if  条件表达式：
          语句1
          ....
      elif 条件表达式：
          语句1
          ...
      elif 条件表达式：
          语句1
          ...
      ...
      else:
          语句1
          ....

switch

python没有switch-case语句

while

while条件为True时执行，条件为False时执行else，else可以省略

    while  条件表达式：
        语句块1
    else：
        语句块2

for

for循环从集合中取出值执行，集合可以是列表、字典、元组；执行完毕执行else，else可以省略
```
for 变量 in 集合：
    语句1
    语句2
    ...
else：
    语句1
```
for循环一般和range()函数搭配使用
range()函数：
- 返回：range对象，常用返回列表
- 参数:(start,end[,step])，其中包括start不包括end，step是步长

break,continue,pass

break：无条件结束整个循环，简称循环猝死
continue：无条件结束本次循环，从新进入下一轮循环
pass：表示略过，通常用于站位

# 案例示例：冒泡排序
def bubbleSort(nums):
    for i in range(len(nums)-1,0,-1):
        for j in range(i):
            if nums[j] > nums[j+1]:
                nums[j],nums[j+1] = nums[j+1],nums[j]
        print(nums)

nums = [0,9,3,5,7,6,4,8,1,2]
bubbleSort(nums)

################
[0, 3, 5, 7, 6, 4, 8, 1, 2, 9]
[0, 3, 5, 6, 4, 7, 1, 2, 8, 9]
[0, 3, 5, 4, 6, 1, 2, 7, 8, 9]
[0, 3, 4, 5, 1, 2, 6, 7, 8, 9]
[0, 3, 4, 1, 2, 5, 6, 7, 8, 9]
[0, 3, 1, 2, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

readme

这是总结，细节请看：
https://github.com/KiraShen/ipython

画辆宝马开

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python基础知识1

python基础知识1变量数据类型数字字符串列表-list元组-tuple字典-dict集合-set运算符算数运算符比较运算符逻辑运算符赋值运算符位运算符身份运算符成员运算符程序结构ifswitchwhileforbreak,continue,passreadme变量变量包括了：变量的标识、名称、数据；变量名称相同，该变量不一定相同，因为标识不同变量不需要声明，直接赋值，赋值即完成了声明和...
复制链接

扫一扫