【Python】指针、字符串与元组篇

最新推荐文章于 2024-04-29 17:55:25 发布

白白与瓜

最新推荐文章于 2024-04-29 17:55:25 发布

阅读量1.8k

点赞数 1

分类专栏： Python学习文章标签： python 开发语言

本文链接：https://blog.csdn.net/yck1716/article/details/124511125

版权

Python学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

指针

# python中的变量都是指针

# 所有可赋值的东西，即可以出现在赋值号“=”左边的东西，都是指针
# 指针即代表内存单元的地址
# 将指针称作“箭头”更容易理解：所有变量都是箭头，指向内存某处
# 对变量进行赋值的本质，就是让变量（箭头）指向某个地方

# a=3 : a-->3
# b=a : a-->3<--b 让b指向a所指的地方

# is运算符与==的区别
# a is b 为True   说明a和b指向同一个地方
# a==b 为True   说明a和b指向的地方放的东西相同，但是a和b不一定指向相同的地方
# a is b则一定有a==b,但反之不一定
a=[1,2,3,4]
b=[1,2,3,4]
print(a==b)
print(a is b)    #未指向同一个地方
# True
# False
c=a
print(a==c)
print(a is c)    #指向同一个地方
# True
# True
a[2]="ok"
print(c)         #y因为a和c指向同一个地方，所以修改了a[2]，c[2]也会改变。它们俩是一个东西
# [1, 2, 'ok', 4]

# 对int,float,complex,str,tuple类型的变量a和b，
# 只需关注a==b是否成立，关注a is b是否成立无意义。
# 因为这些数据本身都不会更改，不会产生a指向的东西改了b指向的东西也跟着变的情况。
# 对list,dict,set类型的变量a和b，a==b和a is b的结果都需要关注。
# 因为这些数据本身会改变，改变了a指向的内容，说不定b指向的内容也变了

# 列表的元素也可以赋值，因此也是指针
# a=[1,2,3,4]   b=[1,2,3,4]
# a-->[ , , , ]
#      | | | |
#      1 2 3 4
#      | | | |
# b-->[ , , , ]-

字符串

1 基础

#转义字符
# '\'及其后的某些字符会构成转义字符，即两个字符当一个字符来看
print("hello\nworld\tok\"1\\2") #\n \t \" \\都是转义字符 分别代表换行，制表符，双引号，斜杠
# hello
# world   ok"1\2

# print(a\nb)不合法：转义字符只出现在字符串中，必须有引号

#规定'\'不转义的字符串
print(r'ab\ncd')
# ab\ncd

2 切片

# 区间是左闭右开，终点不算
a="ABCD"
print(a[1:2])
print(a[0:-1])
print(a[-3:-1])
print(a[2:])
print(a[:3])
print("abcd"[2:3])
# B
# ABC
# BC
# CD
# ABC
# c

# a[x:y:z] 每z个取一个
print("1234"[3:1:-1])
print("abcde"[::1])       #x.y省略则表示从头取到尾     该形式可实现字符串反转
print("12345678"[1:7:2])
print("12345678"[7:1:-2])
# 43
# abcde
# 246
# 864

3 分割

a="12..34.5346...a"
print(a.split(".."))
print(a.split("."))
print(a.split("34"))
# ['12', '34.5346', '.a']
# ['12', '', '34', '5346', '', '', 'a']
# ['12..', '.5', '6...a']

#存在多种分隔符的字符串分割（如将段落分割为单词）
import re
a='Beautiful, is; better*than\nugly'
print(re.split(';| |,|\*|\n',a))  #分隔串用 | 隔开
# ';'   ' '   ','    '*'    '\n'   都被看作分隔串
#   两个相邻的分隔符之间，会隔出一个空串

4 相关函数

# count 求子串出现次数
s='thisAAbb AA'
print(s.count('AA'))
# 2

#len 求字符串长度
s='1234'
print(len(s))
# 4

# upper,lower 转大小写
s="abc"
print(s.upper())
print(s)   #s本身不改变
# ABC
# abc

# find,rfind,index,rindex
# 在字符串中查找子串，返回找到的位置（下标）。找不到的话，find返回-1，index引发异常
s="1234abc567abc12"
# find从头开始找，rfind从尾巴开始找，返回第一个找到的位置
print(s.find("ab"))
print(s.rfind("ab"))
# 4
# 10
print(s.find("12",4))    #指定从下标4处开始查找
# 13
#（若要多次查找，可以将此形式与循环结合，每查找一次，起点便向后移动）
try:
    s.index("afb")       #找不到“afb”因此会产生异常
except Exception as e:
    print(e)
# substring not found

# replace 替换
s="1234abc567abc12"
b=s.replace("abc","FGHI")
print(b)
print(s)
print(s.replace("abc",""))
# 1234FGHI567FGHI12
# 1234abc567abc12
# 123456712

# isdigit()判断字符串是否是数
print("123.4".isdigit())
print("123".isdigit())
print("a123.4".isdigit())
# False
# True
# False

# islower(),isupper()是否全是小/大写等
print("Ab123".islower())
print("ab123".islower())
# False
# True

# startswith,endswith判断字符串是否以某子串开头、结尾
print("abcd".startswith("ab"))
print("abcd".endswith("bcd"))
print("abcd".endswith("bed"))
# True
# True
# False

# strip() 返回除去头尾空白字符（空格，'\r' '\t' '\n'）后的字符串
# lstrip() 返回除去头部（左端）空白字符后的字符串
# rstrip() 返回除去尾部（右端）空白字符后的字符串
print(" \t12 34 \n ".strip())
print(" \t12 34 5".lstrip())
# 12 34
# 12 34 5
# strip(s),lstrip(s),rstrip(s) 返回除去两端、左端、右端在s中出现的字符后的字符串
print("takeab \n".strip("ba \n"))     #去除两端 'b','a',' ','\n'
print("cd\t12 34 5".lstrip("d\tc"))   #去除左端 'd','\t','c'
# take
# 12 34 5

isinstance函数与len函数

#isinstance函数 用来查询数据x是否是类型y
a="1233"
print(isinstance(a,str))
print(isinstance(a,int))
b=(1,3,)  #元组
print(isinstance(b,tuple))
# True
# False
# True

#len函数 用来求组合数据类型的元素个数/长度
print(len("12345"))             #求字符串长度    5
print(len([1,2,3,4]))           #求列表长度      4
print(len((1,2,3)))             #求元组长度      3
print(len({1,2,3}))             #求集合元素个数  3
print(len({'tom':2,'jack':3}))  #求字典元素个数  2

5 编码与格式化

# 字符串的编码在内存中的编码是Unicode的，虽然写入文件时可能是gkb或者utf-8的
print(ord("a"))
print(ord("好"))
print(chr(22900))
print(chr(97))
# 97
# 22909
# 奴
# a

# 字符串的格式化
# {序号：宽度.精度 类型}   （宽度可以是0
# > :右对齐
# < :左对齐
# ^ :中对齐
# 如{0:>10.4f}：
# 表示的是第0项是小数，以宽度至少是10字符，右对齐（宽度不足时空格补在左边），保留小数点后4位输出
x="Hello {0} {1:10},you get ${2:0.4f}".format("Mr.","Jack",3.2)
# {1:10}：宽度至少10字符（Jack后面用6个空格补齐）   {2:0.4f}：宽度至少是0，保留小数后四位
print(x)
# Hello Mr. Jack      ,you get $3.2000
x="Hello {0} {1:>10},you get ${2:0.4f}".format("Mr.","Jack",3.2)
# {1:>10}：宽度不足10个，空格补在左边
print(x)
# Hello Mr.       Jack,you get $3.2000
print("Today is %s.%d."%('May',21))
# Today is May.21.

指针

# 字符串的编码在内存中的编码是Unicode的，虽然写入文件时可能是gkb或者utf-8的
print(ord("a"))
print(ord("好"))
print(chr(22900))
print(chr(97))
# 97
# 22909
# 奴
# a

# 字符串的格式化
# {序号：宽度.精度 类型}   （宽度可以是0
# > :右对齐
# < :左对齐
# ^ :中对齐
# 如{0:>10.4f}：
# 表示的是第0项是小数，以宽度至少是10字符，右对齐（宽度不足时空格补在左边），保留小数点后4位输出
x="Hello {0} {1:10},you get ${2:0.4f}".format("Mr.","Jack",3.2)
# {1:10}：宽度至少10字符（Jack后面用6个空格补齐）   {2:0.4f}：宽度至少是0，保留小数后四位
print(x)
# Hello Mr. Jack      ,you get $3.2000
x="Hello {0} {1:>10},you get ${2:0.4f}".format("Mr.","Jack",3.2)
# {1:>10}：宽度不足10个，空格补在左边
print(x)
# Hello Mr.       Jack,you get $3.2000
print("Today is %s.%d."%('May',21))
# Today is May.21.

元组

# 元组不能修改，即不可增删元素，不可对元素赋值，不可修改元素顺序、
# t = 12345 ,54321 ,'hello!'
# t[0] = 0000
# TypeError: 'tuple' object does not support item assignment   远行错误，元组元素不能赋值
# t = ("a",2,3)  合法

t = 12345 ,54321 ,'hello!'    # t是一个元组
print(t[0])
print(t)
# 12345
# (12345, 54321, 'hello!')
u = t, (1 ,2 ,3 ,4 ,5)
print(u)
print(u[0][1])
print(u[1][2])
# ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
# 54321
# 3

#元组的元素内容有可能被修改。例如，如果元素是列表，就可以修改列表
v = ("hello",[1,2,3],[3,2,1])
# v[1] = 32 则运行错误
v[1][0] = 'world'
print(v)
print(len(v))
# ('hello', ['world', 2, 3], [3, 2, 1])
# 3

# 元组的元素都是指针。
# 元组的元素不可以修改，是指不可以改变元组元素的指向，但是元组元素指向的内容，是有可能被修改的

empty = ()             # 空元组
singleton = 'hello',   # 注意末尾的"," 如果没有"," 就不是元组而是字符串了
print(len(empty))
print(len(singleton))
# 0
# 1
x = ('hello',)         # 无逗号则为字符串
print(x)
('hello',)

# 用下标访问元组，以及元组切片
tup1 = ('A','B',1997,2000)
tup2 = (1,2,3,4,5,6,7)
print(tup1[0])
print(tup2[1:5])
print(tup2[::-1])
print(tup2[-1:0:-2])
# A
# (2, 3, 4, 5)
# (7, 6, 5, 4, 3, 2, 1)
# (7, 5, 3)

# 对元组进行连接组合
tup1 = (12,34.56)
tup2 = ('abc','xyz')
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)
# (12, 34.56, 'abc', 'xyz')
tup3 += (10,20)
print(tup3)
# (12, 34.56, 'abc', 'xyz', 10, 20)

# 元组运算和迭代
x = (1,2,3) * 3
print(x)
print(3 in (1,2,3))
# (1, 2, 3, 1, 2, 3, 1, 2, 3)
# True
for i in (1,2,3):
    print(i,end="")
# 123
print()
x = (1,2,3)
b = x
print(b is x)
# True
x += (100,)      # 新建了一个元组
print(x)
print(b)
# (1, 2, 3, 100)
# (1, 2, 3)

# 元组比大小，逐个比较，直到分出胜负
# 如果有两个对应元素不可比较，则runtime error
print((1,'a',12)<(1,'b',7))
print((1,'a')<(1,'a',13))
print((2,'a')>(1,'b',13))
# True
# True
# True
# print((2,'a')<('ab','b',13))
# TypeError: '<' not supported between instances of 'int' and 'str'

# 题：
a = [1,2,3]
b = (a,a)
b[0][1] = 100
print(a,b)
# [1, 100, 3] ([1, 100, 3], [1, 100, 3])

例题（万年历）

# 用元组（或列表）取代复杂分支结构
weekdays = "Monday", "Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"
n = int(input())
if n>7 or n<1:
    print("Illegal")
else:
    print(weekdays[n-1])

# 万年历：
# 已知2012年1月25日是星期三，编写一个程序，输入用“年 月 日”表示的一个2012年1月25日以后的日期
# 输出该日期是星期几（星期天输出0）
# 思路：2012年1月22日是星期天。算出给定日期是从该天起过了x天，然后输出x%7
monthDays = [-1,31,28,31,30,31,30,31,31,30,31,30,31]
days = 0
lst = input().split()
year,month,date = int(lst[0]),int(lst[1]),int(lst[2])
#法一
for y in range(2012,year):
    if y%4 == 0 and y%100 != 0:  # 闰年
        days += 366
    else:
        days += 365
if year%4 == 0 and year%100 != 0 or year%400 == 0:
    monthDays[2] = 29
for i in range(1,month):
    days += monthDays[i]
days += date
days -= 22  #扣掉2012年的前22天
print(days%7)
# 法二
days = 0
days += (year -2012)*365
if year > 2012:
    days += (year-2012-1)//4+1   # 补上闰年多的一天
days -= (year-2000-1)//100-(year-2000-1)//400

白白与瓜

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
【Python】指针、字符串与元组篇

目录指针字符串1 基础2 切片3 分割4 相关函数5 编码与格式化指针元组例题（万年历）指针# python中的变量都是指针# 所有可赋值的东西，即可以出现在赋值号“=”左边的东西，都是指针# 指针即代表内存单元的地址# 将指针称作“箭头”更容易理解：所有变量都是箭头，指向内存某处# 对变量进行赋值的本质，就是让变量（箭头）指向某个地方# a=3 : a-->3# b=a : a-->3<--b 让b指向a所指的地方#
复制链接

扫一扫